documents.go

// Code generated by Fern. DO NOT EDIT.

package cloudpdf

import (
	json "encoding/json"
	fmt "fmt"
	internal "github.com/embedpdf/cloudpdf-sdk-go/v3/internal"
	io "io"
	big "math/big"
)

var (
	documentsCommitRequestFieldTenantID = big.NewInt(1 << 0)
	documentsCommitRequestFieldID       = big.NewInt(1 << 1)
	documentsCommitRequestFieldSha256   = big.NewInt(1 << 2)
)

type DocumentsCommitRequest struct {
	TenantID string `json:"-" url:"-"`
	ID       string `json:"-" url:"-"`
	Sha256   string `json:"sha256" url:"-"`

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

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

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsCommitRequest) SetTenantID(tenantID string) {
	d.TenantID = tenantID
	d.require(documentsCommitRequestFieldTenantID)
}

// 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 (d *DocumentsCommitRequest) SetID(id string) {
	d.ID = id
	d.require(documentsCommitRequestFieldID)
}

// SetSha256 sets the Sha256 field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsCommitRequest) SetSha256(sha256 string) {
	d.Sha256 = sha256
	d.require(documentsCommitRequestFieldSha256)
}

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

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

var (
	deleteDocumentsRequestFieldTenantID = big.NewInt(1 << 0)
	deleteDocumentsRequestFieldID       = big.NewInt(1 << 1)
)

type DeleteDocumentsRequest struct {
	TenantID string `json:"-" url:"-"`
	ID       string `json:"-" url:"-"`

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

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

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DeleteDocumentsRequest) SetTenantID(tenantID string) {
	d.TenantID = tenantID
	d.require(deleteDocumentsRequestFieldTenantID)
}

// 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 (d *DeleteDocumentsRequest) SetID(id string) {
	d.ID = id
	d.require(deleteDocumentsRequestFieldID)
}

var (
	downloadDocumentsRequestFieldTenantID = big.NewInt(1 << 0)
	downloadDocumentsRequestFieldID       = big.NewInt(1 << 1)
)

type DownloadDocumentsRequest struct {
	TenantID string `json:"-" url:"-"`
	ID       string `json:"-" url:"-"`

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

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

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DownloadDocumentsRequest) SetTenantID(tenantID string) {
	d.TenantID = tenantID
	d.require(downloadDocumentsRequestFieldTenantID)
}

// 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 (d *DownloadDocumentsRequest) SetID(id string) {
	d.ID = id
	d.require(downloadDocumentsRequestFieldID)
}

var (
	getDocumentsRequestFieldTenantID = big.NewInt(1 << 0)
	getDocumentsRequestFieldID       = big.NewInt(1 << 1)
)

type GetDocumentsRequest struct {
	TenantID string `json:"-" url:"-"`
	ID       string `json:"-" url:"-"`

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

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

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (g *GetDocumentsRequest) SetTenantID(tenantID string) {
	g.TenantID = tenantID
	g.require(getDocumentsRequestFieldTenantID)
}

// 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 (g *GetDocumentsRequest) SetID(id string) {
	g.ID = id
	g.require(getDocumentsRequestFieldID)
}

var (
	documentsImportFromRequestFieldTenantID       = big.NewInt(1 << 0)
	documentsImportFromRequestFieldSource         = big.NewInt(1 << 1)
	documentsImportFromRequestFieldExpected       = big.NewInt(1 << 2)
	documentsImportFromRequestFieldMetadata       = big.NewInt(1 << 3)
	documentsImportFromRequestFieldIdempotencyKey = big.NewInt(1 << 4)
	documentsImportFromRequestFieldDedupMode      = big.NewInt(1 << 5)
	documentsImportFromRequestFieldDocID          = big.NewInt(1 << 6)
	documentsImportFromRequestFieldMode           = big.NewInt(1 << 7)
)

type DocumentsImportFromRequest struct {
	TenantID string `json:"-" url:"-"`
	// Where CloudPDF pulls the bytes from. The two shapes differ in who supplies the authority to read, not in which storage vendor holds the file.
	Source *DocumentsImportFromRequestSource `json:"source" url:"-"`
	// Integrity pins, enforced when present. When absent, the server-observed values become authoritative.
	Expected *DocumentsImportFromRequestExpected `json:"expected,omitempty" url:"-"`
	Metadata map[string]any                      `json:"metadata,omitempty" url:"-"`
	// Retrying with the same key resumes the same document rather than importing a second copy — including after a 502.
	IdempotencyKey *string `json:"idempotencyKey,omitempty" url:"-"`
	// always-create (default) creates a new document every time. reuse-existing returns a document that already holds the same content instead of storing it twice.
	DedupMode *DocumentsImportFromRequestDedupMode `json:"dedupMode,omitempty" url:"-"`
	DocID     *string                              `json:"docId,omitempty" url:"-"`
	// sync (default) holds the response open for the whole transfer. async answers 202 with the document pending and transfers in the background; it requires a connection source, and filesystem connections additionally require expected.sha256.
	Mode *DocumentsImportFromRequestMode `json:"mode,omitempty" url:"-"`

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

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

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFromRequest) SetTenantID(tenantID string) {
	d.TenantID = tenantID
	d.require(documentsImportFromRequestFieldTenantID)
}

// SetSource sets the Source field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFromRequest) SetSource(source *DocumentsImportFromRequestSource) {
	d.Source = source
	d.require(documentsImportFromRequestFieldSource)
}

// SetExpected sets the Expected field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFromRequest) SetExpected(expected *DocumentsImportFromRequestExpected) {
	d.Expected = expected
	d.require(documentsImportFromRequestFieldExpected)
}

// SetMetadata sets the Metadata field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFromRequest) SetMetadata(metadata map[string]any) {
	d.Metadata = metadata
	d.require(documentsImportFromRequestFieldMetadata)
}

// SetIdempotencyKey sets the IdempotencyKey field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFromRequest) SetIdempotencyKey(idempotencyKey *string) {
	d.IdempotencyKey = idempotencyKey
	d.require(documentsImportFromRequestFieldIdempotencyKey)
}

// SetDedupMode sets the DedupMode field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFromRequest) SetDedupMode(dedupMode *DocumentsImportFromRequestDedupMode) {
	d.DedupMode = dedupMode
	d.require(documentsImportFromRequestFieldDedupMode)
}

// SetDocID sets the DocID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFromRequest) SetDocID(docID *string) {
	d.DocID = docID
	d.require(documentsImportFromRequestFieldDocID)
}

// SetMode sets the Mode field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFromRequest) SetMode(mode *DocumentsImportFromRequestMode) {
	d.Mode = mode
	d.require(documentsImportFromRequestFieldMode)
}

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

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

var (
	documentsInitRequestFieldTenantID         = big.NewInt(1 << 0)
	documentsInitRequestFieldContentLength    = big.NewInt(1 << 1)
	documentsInitRequestFieldContentSha256    = big.NewInt(1 << 2)
	documentsInitRequestFieldMetadata         = big.NewInt(1 << 3)
	documentsInitRequestFieldIdempotencyKey   = big.NewInt(1 << 4)
	documentsInitRequestFieldDedupMode        = big.NewInt(1 << 5)
	documentsInitRequestFieldDocID            = big.NewInt(1 << 6)
	documentsInitRequestFieldUploadTTLSec     = big.NewInt(1 << 7)
	documentsInitRequestFieldUploadPreference = big.NewInt(1 << 8)
)

type DocumentsInitRequest struct {
	TenantID       string         `json:"-" url:"-"`
	ContentLength  float64        `json:"contentLength" url:"-"`
	ContentSha256  string         `json:"contentSha256" url:"-"`
	Metadata       map[string]any `json:"metadata,omitempty" url:"-"`
	IdempotencyKey *string        `json:"idempotencyKey,omitempty" url:"-"`
	// always-create (default) creates a new document every time. reuse-existing returns a document that already holds the same content instead of storing it twice.
	DedupMode        *DocumentsInitRequestDedupMode        `json:"dedupMode,omitempty" url:"-"`
	DocID            *string                               `json:"docId,omitempty" url:"-"`
	UploadTTLSec     *float64                              `json:"uploadTtlSec,omitempty" url:"-"`
	UploadPreference *DocumentsInitRequestUploadPreference `json:"uploadPreference,omitempty" url:"-"`

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

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

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInitRequest) SetTenantID(tenantID string) {
	d.TenantID = tenantID
	d.require(documentsInitRequestFieldTenantID)
}

// SetContentLength sets the ContentLength field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInitRequest) SetContentLength(contentLength float64) {
	d.ContentLength = contentLength
	d.require(documentsInitRequestFieldContentLength)
}

// SetContentSha256 sets the ContentSha256 field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInitRequest) SetContentSha256(contentSha256 string) {
	d.ContentSha256 = contentSha256
	d.require(documentsInitRequestFieldContentSha256)
}

// SetMetadata sets the Metadata field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInitRequest) SetMetadata(metadata map[string]any) {
	d.Metadata = metadata
	d.require(documentsInitRequestFieldMetadata)
}

// SetIdempotencyKey sets the IdempotencyKey field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInitRequest) SetIdempotencyKey(idempotencyKey *string) {
	d.IdempotencyKey = idempotencyKey
	d.require(documentsInitRequestFieldIdempotencyKey)
}

// SetDedupMode sets the DedupMode field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInitRequest) SetDedupMode(dedupMode *DocumentsInitRequestDedupMode) {
	d.DedupMode = dedupMode
	d.require(documentsInitRequestFieldDedupMode)
}

// SetDocID sets the DocID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInitRequest) SetDocID(docID *string) {
	d.DocID = docID
	d.require(documentsInitRequestFieldDocID)
}

// SetUploadTTLSec sets the UploadTTLSec field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInitRequest) SetUploadTTLSec(uploadTTLSec *float64) {
	d.UploadTTLSec = uploadTTLSec
	d.require(documentsInitRequestFieldUploadTTLSec)
}

// SetUploadPreference sets the UploadPreference field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInitRequest) SetUploadPreference(uploadPreference *DocumentsInitRequestUploadPreference) {
	d.UploadPreference = uploadPreference
	d.require(documentsInitRequestFieldUploadPreference)
}

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

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

var (
	listDocumentsRequestFieldTenantID = big.NewInt(1 << 0)
	listDocumentsRequestFieldLimit    = big.NewInt(1 << 1)
	listDocumentsRequestFieldCursor   = big.NewInt(1 << 2)
	listDocumentsRequestFieldState    = big.NewInt(1 << 3)
)

type ListDocumentsRequest struct {
	TenantID string                     `json:"-" url:"-"`
	Limit    *int                       `json:"-" url:"limit,omitempty"`
	Cursor   *string                    `json:"-" url:"cursor,omitempty"`
	State    *ListDocumentsRequestState `json:"-" url:"state,omitempty"`

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

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

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (l *ListDocumentsRequest) SetTenantID(tenantID string) {
	l.TenantID = tenantID
	l.require(listDocumentsRequestFieldTenantID)
}

// 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 (l *ListDocumentsRequest) SetLimit(limit *int) {
	l.Limit = limit
	l.require(listDocumentsRequestFieldLimit)
}

// SetCursor sets the Cursor field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (l *ListDocumentsRequest) SetCursor(cursor *string) {
	l.Cursor = cursor
	l.require(listDocumentsRequestFieldCursor)
}

// SetState sets the State field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (l *ListDocumentsRequest) SetState(state *ListDocumentsRequestState) {
	l.State = state
	l.require(listDocumentsRequestFieldState)
}

var (
	thumbnailDocumentsRequestFieldTenantID = big.NewInt(1 << 0)
	thumbnailDocumentsRequestFieldID       = big.NewInt(1 << 1)
)

type ThumbnailDocumentsRequest struct {
	TenantID string `json:"-" url:"-"`
	ID       string `json:"-" url:"-"`

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

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

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (t *ThumbnailDocumentsRequest) SetTenantID(tenantID string) {
	t.TenantID = tenantID
	t.require(thumbnailDocumentsRequestFieldTenantID)
}

// 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 (t *ThumbnailDocumentsRequest) SetID(id string) {
	t.ID = id
	t.require(thumbnailDocumentsRequestFieldID)
}

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

type DocumentsCommit200Response struct {
	Document *DocumentsCommit200ResponseDocument `json:"document" url:"document"`

	// 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 *DocumentsCommit200Response) GetDocument() *DocumentsCommit200ResponseDocument {
	if d == nil {
		return nil
	}
	return d.Document
}

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

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

// SetDocument sets the Document field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsCommit200Response) SetDocument(document *DocumentsCommit200ResponseDocument) {
	d.Document = document
	d.require(documentsCommit200ResponseFieldDocument)
}

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

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

func (d *DocumentsCommit200Response) String() string {
	if d == nil {
		return "<nil>"
	}
	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 (
	documentsCommit200ResponseDocumentFieldID               = big.NewInt(1 << 0)
	documentsCommit200ResponseDocumentFieldTenantID         = big.NewInt(1 << 1)
	documentsCommit200ResponseDocumentFieldState            = big.NewInt(1 << 2)
	documentsCommit200ResponseDocumentFieldBaseSha          = big.NewInt(1 << 3)
	documentsCommit200ResponseDocumentFieldStorageSizeBytes = big.NewInt(1 << 4)
	documentsCommit200ResponseDocumentFieldMetadata         = big.NewInt(1 << 5)
	documentsCommit200ResponseDocumentFieldIdempotencyKey   = big.NewInt(1 << 6)
	documentsCommit200ResponseDocumentFieldFailureReason    = big.NewInt(1 << 7)
	documentsCommit200ResponseDocumentFieldThumbnailState   = big.NewInt(1 << 8)
	documentsCommit200ResponseDocumentFieldThumbnailURL     = big.NewInt(1 << 9)
	documentsCommit200ResponseDocumentFieldCreatedAt        = big.NewInt(1 << 10)
	documentsCommit200ResponseDocumentFieldUpdatedAt        = big.NewInt(1 << 11)
	documentsCommit200ResponseDocumentFieldCreatedBy        = big.NewInt(1 << 12)
)

type DocumentsCommit200ResponseDocument struct {
	ID               string                                            `json:"id" url:"id"`
	TenantID         string                                            `json:"tenantId" url:"tenantId"`
	State            DocumentsCommit200ResponseDocumentState           `json:"state" url:"state"`
	BaseSha          *string                                           `json:"baseSha,omitempty" url:"baseSha,omitempty"`
	StorageSizeBytes *float64                                          `json:"storageSizeBytes,omitempty" url:"storageSizeBytes,omitempty"`
	Metadata         map[string]any                                    `json:"metadata,omitempty" url:"metadata,omitempty"`
	IdempotencyKey   *string                                           `json:"idempotencyKey,omitempty" url:"idempotencyKey,omitempty"`
	FailureReason    *string                                           `json:"failureReason,omitempty" url:"failureReason,omitempty"`
	ThumbnailState   *DocumentsCommit200ResponseDocumentThumbnailState `json:"thumbnailState,omitempty" url:"thumbnailState,omitempty"`
	ThumbnailURL     *string                                           `json:"thumbnailUrl,omitempty" url:"thumbnailUrl,omitempty"`
	CreatedAt        float64                                           `json:"createdAt" url:"createdAt"`
	UpdatedAt        float64                                           `json:"updatedAt" url:"updatedAt"`
	CreatedBy        *string                                           `json:"createdBy,omitempty" url:"createdBy,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 (d *DocumentsCommit200ResponseDocument) GetID() string {
	if d == nil {
		return ""
	}
	return d.ID
}

func (d *DocumentsCommit200ResponseDocument) GetTenantID() string {
	if d == nil {
		return ""
	}
	return d.TenantID
}

func (d *DocumentsCommit200ResponseDocument) GetState() DocumentsCommit200ResponseDocumentState {
	if d == nil {
		return ""
	}
	return d.State
}

func (d *DocumentsCommit200ResponseDocument) GetBaseSha() *string {
	if d == nil {
		return nil
	}
	return d.BaseSha
}

func (d *DocumentsCommit200ResponseDocument) GetStorageSizeBytes() *float64 {
	if d == nil {
		return nil
	}
	return d.StorageSizeBytes
}

func (d *DocumentsCommit200ResponseDocument) GetMetadata() map[string]any {
	if d == nil {
		return nil
	}
	return d.Metadata
}

func (d *DocumentsCommit200ResponseDocument) GetIdempotencyKey() *string {
	if d == nil {
		return nil
	}
	return d.IdempotencyKey
}

func (d *DocumentsCommit200ResponseDocument) GetFailureReason() *string {
	if d == nil {
		return nil
	}
	return d.FailureReason
}

func (d *DocumentsCommit200ResponseDocument) GetThumbnailState() *DocumentsCommit200ResponseDocumentThumbnailState {
	if d == nil {
		return nil
	}
	return d.ThumbnailState
}

func (d *DocumentsCommit200ResponseDocument) GetThumbnailURL() *string {
	if d == nil {
		return nil
	}
	return d.ThumbnailURL
}

func (d *DocumentsCommit200ResponseDocument) GetCreatedAt() float64 {
	if d == nil {
		return 0
	}
	return d.CreatedAt
}

func (d *DocumentsCommit200ResponseDocument) GetUpdatedAt() float64 {
	if d == nil {
		return 0
	}
	return d.UpdatedAt
}

func (d *DocumentsCommit200ResponseDocument) GetCreatedBy() *string {
	if d == nil {
		return nil
	}
	return d.CreatedBy
}

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

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

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsCommit200ResponseDocument) SetTenantID(tenantID string) {
	d.TenantID = tenantID
	d.require(documentsCommit200ResponseDocumentFieldTenantID)
}

// SetState sets the State field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsCommit200ResponseDocument) SetState(state DocumentsCommit200ResponseDocumentState) {
	d.State = state
	d.require(documentsCommit200ResponseDocumentFieldState)
}

// SetBaseSha sets the BaseSha field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsCommit200ResponseDocument) SetBaseSha(baseSha *string) {
	d.BaseSha = baseSha
	d.require(documentsCommit200ResponseDocumentFieldBaseSha)
}

// SetStorageSizeBytes sets the StorageSizeBytes field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsCommit200ResponseDocument) SetStorageSizeBytes(storageSizeBytes *float64) {
	d.StorageSizeBytes = storageSizeBytes
	d.require(documentsCommit200ResponseDocumentFieldStorageSizeBytes)
}

// SetMetadata sets the Metadata field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsCommit200ResponseDocument) SetMetadata(metadata map[string]any) {
	d.Metadata = metadata
	d.require(documentsCommit200ResponseDocumentFieldMetadata)
}

// SetIdempotencyKey sets the IdempotencyKey field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsCommit200ResponseDocument) SetIdempotencyKey(idempotencyKey *string) {
	d.IdempotencyKey = idempotencyKey
	d.require(documentsCommit200ResponseDocumentFieldIdempotencyKey)
}

// SetFailureReason sets the FailureReason field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsCommit200ResponseDocument) SetFailureReason(failureReason *string) {
	d.FailureReason = failureReason
	d.require(documentsCommit200ResponseDocumentFieldFailureReason)
}

// SetThumbnailState sets the ThumbnailState field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsCommit200ResponseDocument) SetThumbnailState(thumbnailState *DocumentsCommit200ResponseDocumentThumbnailState) {
	d.ThumbnailState = thumbnailState
	d.require(documentsCommit200ResponseDocumentFieldThumbnailState)
}

// SetThumbnailURL sets the ThumbnailURL field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsCommit200ResponseDocument) SetThumbnailURL(thumbnailURL *string) {
	d.ThumbnailURL = thumbnailURL
	d.require(documentsCommit200ResponseDocumentFieldThumbnailURL)
}

// 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 (d *DocumentsCommit200ResponseDocument) SetCreatedAt(createdAt float64) {
	d.CreatedAt = createdAt
	d.require(documentsCommit200ResponseDocumentFieldCreatedAt)
}

// 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 (d *DocumentsCommit200ResponseDocument) SetUpdatedAt(updatedAt float64) {
	d.UpdatedAt = updatedAt
	d.require(documentsCommit200ResponseDocumentFieldUpdatedAt)
}

// SetCreatedBy sets the CreatedBy field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsCommit200ResponseDocument) SetCreatedBy(createdBy *string) {
	d.CreatedBy = createdBy
	d.require(documentsCommit200ResponseDocumentFieldCreatedBy)
}

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

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

func (d *DocumentsCommit200ResponseDocument) String() string {
	if d == nil {
		return "<nil>"
	}
	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)
}

type DocumentsCommit200ResponseDocumentState string

const (
	DocumentsCommit200ResponseDocumentStatePending  DocumentsCommit200ResponseDocumentState = "pending"
	DocumentsCommit200ResponseDocumentStateReady    DocumentsCommit200ResponseDocumentState = "ready"
	DocumentsCommit200ResponseDocumentStateFailed   DocumentsCommit200ResponseDocumentState = "failed"
	DocumentsCommit200ResponseDocumentStateDeleting DocumentsCommit200ResponseDocumentState = "deleting"
)

func NewDocumentsCommit200ResponseDocumentStateFromString(s string) (DocumentsCommit200ResponseDocumentState, error) {
	switch s {
	case "pending":
		return DocumentsCommit200ResponseDocumentStatePending, nil
	case "ready":
		return DocumentsCommit200ResponseDocumentStateReady, nil
	case "failed":
		return DocumentsCommit200ResponseDocumentStateFailed, nil
	case "deleting":
		return DocumentsCommit200ResponseDocumentStateDeleting, nil
	}
	var t DocumentsCommit200ResponseDocumentState
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsCommit200ResponseDocumentState) Ptr() *DocumentsCommit200ResponseDocumentState {
	return &d
}

type DocumentsCommit200ResponseDocumentThumbnailState string

const (
	DocumentsCommit200ResponseDocumentThumbnailStatePending DocumentsCommit200ResponseDocumentThumbnailState = "pending"
	DocumentsCommit200ResponseDocumentThumbnailStateReady   DocumentsCommit200ResponseDocumentThumbnailState = "ready"
	DocumentsCommit200ResponseDocumentThumbnailStateLocked  DocumentsCommit200ResponseDocumentThumbnailState = "locked"
	DocumentsCommit200ResponseDocumentThumbnailStateFailed  DocumentsCommit200ResponseDocumentThumbnailState = "failed"
)

func NewDocumentsCommit200ResponseDocumentThumbnailStateFromString(s string) (DocumentsCommit200ResponseDocumentThumbnailState, error) {
	switch s {
	case "pending":
		return DocumentsCommit200ResponseDocumentThumbnailStatePending, nil
	case "ready":
		return DocumentsCommit200ResponseDocumentThumbnailStateReady, nil
	case "locked":
		return DocumentsCommit200ResponseDocumentThumbnailStateLocked, nil
	case "failed":
		return DocumentsCommit200ResponseDocumentThumbnailStateFailed, nil
	}
	var t DocumentsCommit200ResponseDocumentThumbnailState
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsCommit200ResponseDocumentThumbnailState) Ptr() *DocumentsCommit200ResponseDocumentThumbnailState {
	return &d
}

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

type DocumentsGet200Response struct {
	Document *DocumentsGet200ResponseDocument `json:"document" url:"document"`

	// 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 *DocumentsGet200Response) GetDocument() *DocumentsGet200ResponseDocument {
	if d == nil {
		return nil
	}
	return d.Document
}

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

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

// SetDocument sets the Document field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsGet200Response) SetDocument(document *DocumentsGet200ResponseDocument) {
	d.Document = document
	d.require(documentsGet200ResponseFieldDocument)
}

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

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

func (d *DocumentsGet200Response) String() string {
	if d == nil {
		return "<nil>"
	}
	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 (
	documentsGet200ResponseDocumentFieldID               = big.NewInt(1 << 0)
	documentsGet200ResponseDocumentFieldTenantID         = big.NewInt(1 << 1)
	documentsGet200ResponseDocumentFieldState            = big.NewInt(1 << 2)
	documentsGet200ResponseDocumentFieldBaseSha          = big.NewInt(1 << 3)
	documentsGet200ResponseDocumentFieldStorageSizeBytes = big.NewInt(1 << 4)
	documentsGet200ResponseDocumentFieldMetadata         = big.NewInt(1 << 5)
	documentsGet200ResponseDocumentFieldIdempotencyKey   = big.NewInt(1 << 6)
	documentsGet200ResponseDocumentFieldFailureReason    = big.NewInt(1 << 7)
	documentsGet200ResponseDocumentFieldThumbnailState   = big.NewInt(1 << 8)
	documentsGet200ResponseDocumentFieldThumbnailURL     = big.NewInt(1 << 9)
	documentsGet200ResponseDocumentFieldCreatedAt        = big.NewInt(1 << 10)
	documentsGet200ResponseDocumentFieldUpdatedAt        = big.NewInt(1 << 11)
	documentsGet200ResponseDocumentFieldCreatedBy        = big.NewInt(1 << 12)
)

type DocumentsGet200ResponseDocument struct {
	ID               string                                         `json:"id" url:"id"`
	TenantID         string                                         `json:"tenantId" url:"tenantId"`
	State            DocumentsGet200ResponseDocumentState           `json:"state" url:"state"`
	BaseSha          *string                                        `json:"baseSha,omitempty" url:"baseSha,omitempty"`
	StorageSizeBytes *float64                                       `json:"storageSizeBytes,omitempty" url:"storageSizeBytes,omitempty"`
	Metadata         map[string]any                                 `json:"metadata,omitempty" url:"metadata,omitempty"`
	IdempotencyKey   *string                                        `json:"idempotencyKey,omitempty" url:"idempotencyKey,omitempty"`
	FailureReason    *string                                        `json:"failureReason,omitempty" url:"failureReason,omitempty"`
	ThumbnailState   *DocumentsGet200ResponseDocumentThumbnailState `json:"thumbnailState,omitempty" url:"thumbnailState,omitempty"`
	ThumbnailURL     *string                                        `json:"thumbnailUrl,omitempty" url:"thumbnailUrl,omitempty"`
	CreatedAt        float64                                        `json:"createdAt" url:"createdAt"`
	UpdatedAt        float64                                        `json:"updatedAt" url:"updatedAt"`
	CreatedBy        *string                                        `json:"createdBy,omitempty" url:"createdBy,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 (d *DocumentsGet200ResponseDocument) GetID() string {
	if d == nil {
		return ""
	}
	return d.ID
}

func (d *DocumentsGet200ResponseDocument) GetTenantID() string {
	if d == nil {
		return ""
	}
	return d.TenantID
}

func (d *DocumentsGet200ResponseDocument) GetState() DocumentsGet200ResponseDocumentState {
	if d == nil {
		return ""
	}
	return d.State
}

func (d *DocumentsGet200ResponseDocument) GetBaseSha() *string {
	if d == nil {
		return nil
	}
	return d.BaseSha
}

func (d *DocumentsGet200ResponseDocument) GetStorageSizeBytes() *float64 {
	if d == nil {
		return nil
	}
	return d.StorageSizeBytes
}

func (d *DocumentsGet200ResponseDocument) GetMetadata() map[string]any {
	if d == nil {
		return nil
	}
	return d.Metadata
}

func (d *DocumentsGet200ResponseDocument) GetIdempotencyKey() *string {
	if d == nil {
		return nil
	}
	return d.IdempotencyKey
}

func (d *DocumentsGet200ResponseDocument) GetFailureReason() *string {
	if d == nil {
		return nil
	}
	return d.FailureReason
}

func (d *DocumentsGet200ResponseDocument) GetThumbnailState() *DocumentsGet200ResponseDocumentThumbnailState {
	if d == nil {
		return nil
	}
	return d.ThumbnailState
}

func (d *DocumentsGet200ResponseDocument) GetThumbnailURL() *string {
	if d == nil {
		return nil
	}
	return d.ThumbnailURL
}

func (d *DocumentsGet200ResponseDocument) GetCreatedAt() float64 {
	if d == nil {
		return 0
	}
	return d.CreatedAt
}

func (d *DocumentsGet200ResponseDocument) GetUpdatedAt() float64 {
	if d == nil {
		return 0
	}
	return d.UpdatedAt
}

func (d *DocumentsGet200ResponseDocument) GetCreatedBy() *string {
	if d == nil {
		return nil
	}
	return d.CreatedBy
}

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

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

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsGet200ResponseDocument) SetTenantID(tenantID string) {
	d.TenantID = tenantID
	d.require(documentsGet200ResponseDocumentFieldTenantID)
}

// SetState sets the State field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsGet200ResponseDocument) SetState(state DocumentsGet200ResponseDocumentState) {
	d.State = state
	d.require(documentsGet200ResponseDocumentFieldState)
}

// SetBaseSha sets the BaseSha field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsGet200ResponseDocument) SetBaseSha(baseSha *string) {
	d.BaseSha = baseSha
	d.require(documentsGet200ResponseDocumentFieldBaseSha)
}

// SetStorageSizeBytes sets the StorageSizeBytes field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsGet200ResponseDocument) SetStorageSizeBytes(storageSizeBytes *float64) {
	d.StorageSizeBytes = storageSizeBytes
	d.require(documentsGet200ResponseDocumentFieldStorageSizeBytes)
}

// SetMetadata sets the Metadata field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsGet200ResponseDocument) SetMetadata(metadata map[string]any) {
	d.Metadata = metadata
	d.require(documentsGet200ResponseDocumentFieldMetadata)
}

// SetIdempotencyKey sets the IdempotencyKey field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsGet200ResponseDocument) SetIdempotencyKey(idempotencyKey *string) {
	d.IdempotencyKey = idempotencyKey
	d.require(documentsGet200ResponseDocumentFieldIdempotencyKey)
}

// SetFailureReason sets the FailureReason field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsGet200ResponseDocument) SetFailureReason(failureReason *string) {
	d.FailureReason = failureReason
	d.require(documentsGet200ResponseDocumentFieldFailureReason)
}

// SetThumbnailState sets the ThumbnailState field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsGet200ResponseDocument) SetThumbnailState(thumbnailState *DocumentsGet200ResponseDocumentThumbnailState) {
	d.ThumbnailState = thumbnailState
	d.require(documentsGet200ResponseDocumentFieldThumbnailState)
}

// SetThumbnailURL sets the ThumbnailURL field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsGet200ResponseDocument) SetThumbnailURL(thumbnailURL *string) {
	d.ThumbnailURL = thumbnailURL
	d.require(documentsGet200ResponseDocumentFieldThumbnailURL)
}

// 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 (d *DocumentsGet200ResponseDocument) SetCreatedAt(createdAt float64) {
	d.CreatedAt = createdAt
	d.require(documentsGet200ResponseDocumentFieldCreatedAt)
}

// 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 (d *DocumentsGet200ResponseDocument) SetUpdatedAt(updatedAt float64) {
	d.UpdatedAt = updatedAt
	d.require(documentsGet200ResponseDocumentFieldUpdatedAt)
}

// SetCreatedBy sets the CreatedBy field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsGet200ResponseDocument) SetCreatedBy(createdBy *string) {
	d.CreatedBy = createdBy
	d.require(documentsGet200ResponseDocumentFieldCreatedBy)
}

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

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

func (d *DocumentsGet200ResponseDocument) String() string {
	if d == nil {
		return "<nil>"
	}
	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)
}

type DocumentsGet200ResponseDocumentState string

const (
	DocumentsGet200ResponseDocumentStatePending  DocumentsGet200ResponseDocumentState = "pending"
	DocumentsGet200ResponseDocumentStateReady    DocumentsGet200ResponseDocumentState = "ready"
	DocumentsGet200ResponseDocumentStateFailed   DocumentsGet200ResponseDocumentState = "failed"
	DocumentsGet200ResponseDocumentStateDeleting DocumentsGet200ResponseDocumentState = "deleting"
)

func NewDocumentsGet200ResponseDocumentStateFromString(s string) (DocumentsGet200ResponseDocumentState, error) {
	switch s {
	case "pending":
		return DocumentsGet200ResponseDocumentStatePending, nil
	case "ready":
		return DocumentsGet200ResponseDocumentStateReady, nil
	case "failed":
		return DocumentsGet200ResponseDocumentStateFailed, nil
	case "deleting":
		return DocumentsGet200ResponseDocumentStateDeleting, nil
	}
	var t DocumentsGet200ResponseDocumentState
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsGet200ResponseDocumentState) Ptr() *DocumentsGet200ResponseDocumentState {
	return &d
}

type DocumentsGet200ResponseDocumentThumbnailState string

const (
	DocumentsGet200ResponseDocumentThumbnailStatePending DocumentsGet200ResponseDocumentThumbnailState = "pending"
	DocumentsGet200ResponseDocumentThumbnailStateReady   DocumentsGet200ResponseDocumentThumbnailState = "ready"
	DocumentsGet200ResponseDocumentThumbnailStateLocked  DocumentsGet200ResponseDocumentThumbnailState = "locked"
	DocumentsGet200ResponseDocumentThumbnailStateFailed  DocumentsGet200ResponseDocumentThumbnailState = "failed"
)

func NewDocumentsGet200ResponseDocumentThumbnailStateFromString(s string) (DocumentsGet200ResponseDocumentThumbnailState, error) {
	switch s {
	case "pending":
		return DocumentsGet200ResponseDocumentThumbnailStatePending, nil
	case "ready":
		return DocumentsGet200ResponseDocumentThumbnailStateReady, nil
	case "locked":
		return DocumentsGet200ResponseDocumentThumbnailStateLocked, nil
	case "failed":
		return DocumentsGet200ResponseDocumentThumbnailStateFailed, nil
	}
	var t DocumentsGet200ResponseDocumentThumbnailState
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsGet200ResponseDocumentThumbnailState) Ptr() *DocumentsGet200ResponseDocumentThumbnailState {
	return &d
}

var (
	documentsImportFrom200ResponseFieldTag      = big.NewInt(1 << 0)
	documentsImportFrom200ResponseFieldDocument = big.NewInt(1 << 1)
)

type DocumentsImportFrom200Response struct {
	Tag      DocumentsImportFrom200ResponseTag       `json:"tag" url:"tag"`
	Document *DocumentsImportFrom200ResponseDocument `json:"document" url:"document"`

	// 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 *DocumentsImportFrom200Response) GetTag() DocumentsImportFrom200ResponseTag {
	if d == nil {
		return ""
	}
	return d.Tag
}

func (d *DocumentsImportFrom200Response) GetDocument() *DocumentsImportFrom200ResponseDocument {
	if d == nil {
		return nil
	}
	return d.Document
}

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

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

// SetTag sets the Tag field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFrom200Response) SetTag(tag DocumentsImportFrom200ResponseTag) {
	d.Tag = tag
	d.require(documentsImportFrom200ResponseFieldTag)
}

// SetDocument sets the Document field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFrom200Response) SetDocument(document *DocumentsImportFrom200ResponseDocument) {
	d.Document = document
	d.require(documentsImportFrom200ResponseFieldDocument)
}

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

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

func (d *DocumentsImportFrom200Response) String() string {
	if d == nil {
		return "<nil>"
	}
	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 (
	documentsImportFrom200ResponseDocumentFieldID               = big.NewInt(1 << 0)
	documentsImportFrom200ResponseDocumentFieldTenantID         = big.NewInt(1 << 1)
	documentsImportFrom200ResponseDocumentFieldState            = big.NewInt(1 << 2)
	documentsImportFrom200ResponseDocumentFieldBaseSha          = big.NewInt(1 << 3)
	documentsImportFrom200ResponseDocumentFieldStorageSizeBytes = big.NewInt(1 << 4)
	documentsImportFrom200ResponseDocumentFieldMetadata         = big.NewInt(1 << 5)
	documentsImportFrom200ResponseDocumentFieldIdempotencyKey   = big.NewInt(1 << 6)
	documentsImportFrom200ResponseDocumentFieldFailureReason    = big.NewInt(1 << 7)
	documentsImportFrom200ResponseDocumentFieldThumbnailState   = big.NewInt(1 << 8)
	documentsImportFrom200ResponseDocumentFieldThumbnailURL     = big.NewInt(1 << 9)
	documentsImportFrom200ResponseDocumentFieldCreatedAt        = big.NewInt(1 << 10)
	documentsImportFrom200ResponseDocumentFieldUpdatedAt        = big.NewInt(1 << 11)
	documentsImportFrom200ResponseDocumentFieldCreatedBy        = big.NewInt(1 << 12)
)

type DocumentsImportFrom200ResponseDocument struct {
	ID               string                                                `json:"id" url:"id"`
	TenantID         string                                                `json:"tenantId" url:"tenantId"`
	State            DocumentsImportFrom200ResponseDocumentState           `json:"state" url:"state"`
	BaseSha          *string                                               `json:"baseSha,omitempty" url:"baseSha,omitempty"`
	StorageSizeBytes *float64                                              `json:"storageSizeBytes,omitempty" url:"storageSizeBytes,omitempty"`
	Metadata         map[string]any                                        `json:"metadata,omitempty" url:"metadata,omitempty"`
	IdempotencyKey   *string                                               `json:"idempotencyKey,omitempty" url:"idempotencyKey,omitempty"`
	FailureReason    *string                                               `json:"failureReason,omitempty" url:"failureReason,omitempty"`
	ThumbnailState   *DocumentsImportFrom200ResponseDocumentThumbnailState `json:"thumbnailState,omitempty" url:"thumbnailState,omitempty"`
	ThumbnailURL     *string                                               `json:"thumbnailUrl,omitempty" url:"thumbnailUrl,omitempty"`
	CreatedAt        float64                                               `json:"createdAt" url:"createdAt"`
	UpdatedAt        float64                                               `json:"updatedAt" url:"updatedAt"`
	CreatedBy        *string                                               `json:"createdBy,omitempty" url:"createdBy,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 (d *DocumentsImportFrom200ResponseDocument) GetID() string {
	if d == nil {
		return ""
	}
	return d.ID
}

func (d *DocumentsImportFrom200ResponseDocument) GetTenantID() string {
	if d == nil {
		return ""
	}
	return d.TenantID
}

func (d *DocumentsImportFrom200ResponseDocument) GetState() DocumentsImportFrom200ResponseDocumentState {
	if d == nil {
		return ""
	}
	return d.State
}

func (d *DocumentsImportFrom200ResponseDocument) GetBaseSha() *string {
	if d == nil {
		return nil
	}
	return d.BaseSha
}

func (d *DocumentsImportFrom200ResponseDocument) GetStorageSizeBytes() *float64 {
	if d == nil {
		return nil
	}
	return d.StorageSizeBytes
}

func (d *DocumentsImportFrom200ResponseDocument) GetMetadata() map[string]any {
	if d == nil {
		return nil
	}
	return d.Metadata
}

func (d *DocumentsImportFrom200ResponseDocument) GetIdempotencyKey() *string {
	if d == nil {
		return nil
	}
	return d.IdempotencyKey
}

func (d *DocumentsImportFrom200ResponseDocument) GetFailureReason() *string {
	if d == nil {
		return nil
	}
	return d.FailureReason
}

func (d *DocumentsImportFrom200ResponseDocument) GetThumbnailState() *DocumentsImportFrom200ResponseDocumentThumbnailState {
	if d == nil {
		return nil
	}
	return d.ThumbnailState
}

func (d *DocumentsImportFrom200ResponseDocument) GetThumbnailURL() *string {
	if d == nil {
		return nil
	}
	return d.ThumbnailURL
}

func (d *DocumentsImportFrom200ResponseDocument) GetCreatedAt() float64 {
	if d == nil {
		return 0
	}
	return d.CreatedAt
}

func (d *DocumentsImportFrom200ResponseDocument) GetUpdatedAt() float64 {
	if d == nil {
		return 0
	}
	return d.UpdatedAt
}

func (d *DocumentsImportFrom200ResponseDocument) GetCreatedBy() *string {
	if d == nil {
		return nil
	}
	return d.CreatedBy
}

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

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

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFrom200ResponseDocument) SetTenantID(tenantID string) {
	d.TenantID = tenantID
	d.require(documentsImportFrom200ResponseDocumentFieldTenantID)
}

// SetState sets the State field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFrom200ResponseDocument) SetState(state DocumentsImportFrom200ResponseDocumentState) {
	d.State = state
	d.require(documentsImportFrom200ResponseDocumentFieldState)
}

// SetBaseSha sets the BaseSha field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFrom200ResponseDocument) SetBaseSha(baseSha *string) {
	d.BaseSha = baseSha
	d.require(documentsImportFrom200ResponseDocumentFieldBaseSha)
}

// SetStorageSizeBytes sets the StorageSizeBytes field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFrom200ResponseDocument) SetStorageSizeBytes(storageSizeBytes *float64) {
	d.StorageSizeBytes = storageSizeBytes
	d.require(documentsImportFrom200ResponseDocumentFieldStorageSizeBytes)
}

// SetMetadata sets the Metadata field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFrom200ResponseDocument) SetMetadata(metadata map[string]any) {
	d.Metadata = metadata
	d.require(documentsImportFrom200ResponseDocumentFieldMetadata)
}

// SetIdempotencyKey sets the IdempotencyKey field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFrom200ResponseDocument) SetIdempotencyKey(idempotencyKey *string) {
	d.IdempotencyKey = idempotencyKey
	d.require(documentsImportFrom200ResponseDocumentFieldIdempotencyKey)
}

// SetFailureReason sets the FailureReason field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFrom200ResponseDocument) SetFailureReason(failureReason *string) {
	d.FailureReason = failureReason
	d.require(documentsImportFrom200ResponseDocumentFieldFailureReason)
}

// SetThumbnailState sets the ThumbnailState field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFrom200ResponseDocument) SetThumbnailState(thumbnailState *DocumentsImportFrom200ResponseDocumentThumbnailState) {
	d.ThumbnailState = thumbnailState
	d.require(documentsImportFrom200ResponseDocumentFieldThumbnailState)
}

// SetThumbnailURL sets the ThumbnailURL field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFrom200ResponseDocument) SetThumbnailURL(thumbnailURL *string) {
	d.ThumbnailURL = thumbnailURL
	d.require(documentsImportFrom200ResponseDocumentFieldThumbnailURL)
}

// 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 (d *DocumentsImportFrom200ResponseDocument) SetCreatedAt(createdAt float64) {
	d.CreatedAt = createdAt
	d.require(documentsImportFrom200ResponseDocumentFieldCreatedAt)
}

// 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 (d *DocumentsImportFrom200ResponseDocument) SetUpdatedAt(updatedAt float64) {
	d.UpdatedAt = updatedAt
	d.require(documentsImportFrom200ResponseDocumentFieldUpdatedAt)
}

// SetCreatedBy sets the CreatedBy field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFrom200ResponseDocument) SetCreatedBy(createdBy *string) {
	d.CreatedBy = createdBy
	d.require(documentsImportFrom200ResponseDocumentFieldCreatedBy)
}

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

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

func (d *DocumentsImportFrom200ResponseDocument) String() string {
	if d == nil {
		return "<nil>"
	}
	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)
}

type DocumentsImportFrom200ResponseDocumentState string

const (
	DocumentsImportFrom200ResponseDocumentStatePending  DocumentsImportFrom200ResponseDocumentState = "pending"
	DocumentsImportFrom200ResponseDocumentStateReady    DocumentsImportFrom200ResponseDocumentState = "ready"
	DocumentsImportFrom200ResponseDocumentStateFailed   DocumentsImportFrom200ResponseDocumentState = "failed"
	DocumentsImportFrom200ResponseDocumentStateDeleting DocumentsImportFrom200ResponseDocumentState = "deleting"
)

func NewDocumentsImportFrom200ResponseDocumentStateFromString(s string) (DocumentsImportFrom200ResponseDocumentState, error) {
	switch s {
	case "pending":
		return DocumentsImportFrom200ResponseDocumentStatePending, nil
	case "ready":
		return DocumentsImportFrom200ResponseDocumentStateReady, nil
	case "failed":
		return DocumentsImportFrom200ResponseDocumentStateFailed, nil
	case "deleting":
		return DocumentsImportFrom200ResponseDocumentStateDeleting, nil
	}
	var t DocumentsImportFrom200ResponseDocumentState
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsImportFrom200ResponseDocumentState) Ptr() *DocumentsImportFrom200ResponseDocumentState {
	return &d
}

type DocumentsImportFrom200ResponseDocumentThumbnailState string

const (
	DocumentsImportFrom200ResponseDocumentThumbnailStatePending DocumentsImportFrom200ResponseDocumentThumbnailState = "pending"
	DocumentsImportFrom200ResponseDocumentThumbnailStateReady   DocumentsImportFrom200ResponseDocumentThumbnailState = "ready"
	DocumentsImportFrom200ResponseDocumentThumbnailStateLocked  DocumentsImportFrom200ResponseDocumentThumbnailState = "locked"
	DocumentsImportFrom200ResponseDocumentThumbnailStateFailed  DocumentsImportFrom200ResponseDocumentThumbnailState = "failed"
)

func NewDocumentsImportFrom200ResponseDocumentThumbnailStateFromString(s string) (DocumentsImportFrom200ResponseDocumentThumbnailState, error) {
	switch s {
	case "pending":
		return DocumentsImportFrom200ResponseDocumentThumbnailStatePending, nil
	case "ready":
		return DocumentsImportFrom200ResponseDocumentThumbnailStateReady, nil
	case "locked":
		return DocumentsImportFrom200ResponseDocumentThumbnailStateLocked, nil
	case "failed":
		return DocumentsImportFrom200ResponseDocumentThumbnailStateFailed, nil
	}
	var t DocumentsImportFrom200ResponseDocumentThumbnailState
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsImportFrom200ResponseDocumentThumbnailState) Ptr() *DocumentsImportFrom200ResponseDocumentThumbnailState {
	return &d
}

type DocumentsImportFrom200ResponseTag string

const (
	DocumentsImportFrom200ResponseTagImported DocumentsImportFrom200ResponseTag = "imported"
	DocumentsImportFrom200ResponseTagDeduped  DocumentsImportFrom200ResponseTag = "deduped"
	DocumentsImportFrom200ResponseTagAccepted DocumentsImportFrom200ResponseTag = "accepted"
)

func NewDocumentsImportFrom200ResponseTagFromString(s string) (DocumentsImportFrom200ResponseTag, error) {
	switch s {
	case "imported":
		return DocumentsImportFrom200ResponseTagImported, nil
	case "deduped":
		return DocumentsImportFrom200ResponseTagDeduped, nil
	case "accepted":
		return DocumentsImportFrom200ResponseTagAccepted, nil
	}
	var t DocumentsImportFrom200ResponseTag
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsImportFrom200ResponseTag) Ptr() *DocumentsImportFrom200ResponseTag {
	return &d
}

type DocumentsInit200Response struct {
	Tag     string
	Created *DocumentsInit200ResponseCreated
	Resumed *DocumentsInit200ResponseResumed
	Deduped *DocumentsInit200ResponseDeduped

	rawJSON json.RawMessage
}

func (d *DocumentsInit200Response) GetTag() string {
	if d == nil {
		return ""
	}
	return d.Tag
}

func (d *DocumentsInit200Response) GetCreated() *DocumentsInit200ResponseCreated {
	if d == nil {
		return nil
	}
	return d.Created
}

func (d *DocumentsInit200Response) GetResumed() *DocumentsInit200ResponseResumed {
	if d == nil {
		return nil
	}
	return d.Resumed
}

func (d *DocumentsInit200Response) GetDeduped() *DocumentsInit200ResponseDeduped {
	if d == nil {
		return nil
	}
	return d.Deduped
}

func (d *DocumentsInit200Response) UnmarshalJSON(data []byte) error {
	var unmarshaler struct {
		Tag string `json:"tag"`
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	d.Tag = unmarshaler.Tag
	if unmarshaler.Tag == "" {
		return fmt.Errorf("%T did not include discriminant tag", d)
	}
	switch unmarshaler.Tag {
	case "created":
		value := new(DocumentsInit200ResponseCreated)
		if err := json.Unmarshal(data, &value); err != nil {
			return err
		}
		d.Created = value
	case "resumed":
		value := new(DocumentsInit200ResponseResumed)
		if err := json.Unmarshal(data, &value); err != nil {
			return err
		}
		d.Resumed = value
	case "deduped":
		value := new(DocumentsInit200ResponseDeduped)
		if err := json.Unmarshal(data, &value); err != nil {
			return err
		}
		d.Deduped = value
	}
	d.rawJSON = json.RawMessage(data)
	return nil
}

func (d DocumentsInit200Response) MarshalJSON() ([]byte, error) {
	if err := d.validate(); err != nil {
		return nil, err
	}
	if d.Created != nil {
		return internal.MarshalJSONWithExtraProperty(d.Created, "tag", "created")
	}
	if d.Resumed != nil {
		return internal.MarshalJSONWithExtraProperty(d.Resumed, "tag", "resumed")
	}
	if d.Deduped != nil {
		return internal.MarshalJSONWithExtraProperty(d.Deduped, "tag", "deduped")
	}
	if len(d.rawJSON) > 0 {
		return d.rawJSON, nil
	}
	return nil, fmt.Errorf("type %T does not define a non-empty union type", d)
}

type DocumentsInit200ResponseVisitor interface {
	VisitCreated(*DocumentsInit200ResponseCreated) error
	VisitResumed(*DocumentsInit200ResponseResumed) error
	VisitDeduped(*DocumentsInit200ResponseDeduped) error
}

func (d *DocumentsInit200Response) Accept(visitor DocumentsInit200ResponseVisitor) error {
	if d.Created != nil {
		return visitor.VisitCreated(d.Created)
	}
	if d.Resumed != nil {
		return visitor.VisitResumed(d.Resumed)
	}
	if d.Deduped != nil {
		return visitor.VisitDeduped(d.Deduped)
	}
	return fmt.Errorf("type %T does not define a non-empty union type", d)
}

func (d *DocumentsInit200Response) validate() error {
	if d == nil {
		return fmt.Errorf("type %T is nil", d)
	}
	var fields []string
	if d.Created != nil {
		fields = append(fields, "created")
	}
	if d.Resumed != nil {
		fields = append(fields, "resumed")
	}
	if d.Deduped != nil {
		fields = append(fields, "deduped")
	}
	if len(fields) == 0 {
		if d.Tag != "" {
			if len(d.rawJSON) > 0 {
				return nil
			}
			return fmt.Errorf("type %T defines a discriminant set to %q but the field is not set", d, d.Tag)
		}
		return fmt.Errorf("type %T is empty", d)
	}
	if len(fields) > 1 {
		return fmt.Errorf("type %T defines values for %s, but only one value is allowed", d, fields)
	}
	if d.Tag != "" {
		field := fields[0]
		if d.Tag != field {
			return fmt.Errorf(
				"type %T defines a discriminant set to %q, but it does not match the %T field; either remove or update the discriminant to match",
				d,
				d.Tag,
				d,
			)
		}
	}
	return nil
}

var (
	documentsInit200ResponseCreatedFieldDocument = big.NewInt(1 << 0)
	documentsInit200ResponseCreatedFieldUpload   = big.NewInt(1 << 1)
)

type DocumentsInit200ResponseCreated struct {
	Document *DocumentsInit200ResponseCreatedDocument `json:"document" url:"document"`
	Upload   *DocumentsInit200ResponseCreatedUpload   `json:"upload" url:"upload"`

	// 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 *DocumentsInit200ResponseCreated) GetDocument() *DocumentsInit200ResponseCreatedDocument {
	if d == nil {
		return nil
	}
	return d.Document
}

func (d *DocumentsInit200ResponseCreated) GetUpload() *DocumentsInit200ResponseCreatedUpload {
	if d == nil {
		return nil
	}
	return d.Upload
}

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

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

// SetDocument sets the Document field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreated) SetDocument(document *DocumentsInit200ResponseCreatedDocument) {
	d.Document = document
	d.require(documentsInit200ResponseCreatedFieldDocument)
}

// SetUpload sets the Upload field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreated) SetUpload(upload *DocumentsInit200ResponseCreatedUpload) {
	d.Upload = upload
	d.require(documentsInit200ResponseCreatedFieldUpload)
}

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

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

func (d *DocumentsInit200ResponseCreated) String() string {
	if d == nil {
		return "<nil>"
	}
	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 (
	documentsInit200ResponseCreatedDocumentFieldID               = big.NewInt(1 << 0)
	documentsInit200ResponseCreatedDocumentFieldTenantID         = big.NewInt(1 << 1)
	documentsInit200ResponseCreatedDocumentFieldState            = big.NewInt(1 << 2)
	documentsInit200ResponseCreatedDocumentFieldBaseSha          = big.NewInt(1 << 3)
	documentsInit200ResponseCreatedDocumentFieldStorageSizeBytes = big.NewInt(1 << 4)
	documentsInit200ResponseCreatedDocumentFieldMetadata         = big.NewInt(1 << 5)
	documentsInit200ResponseCreatedDocumentFieldIdempotencyKey   = big.NewInt(1 << 6)
	documentsInit200ResponseCreatedDocumentFieldFailureReason    = big.NewInt(1 << 7)
	documentsInit200ResponseCreatedDocumentFieldThumbnailState   = big.NewInt(1 << 8)
	documentsInit200ResponseCreatedDocumentFieldThumbnailURL     = big.NewInt(1 << 9)
	documentsInit200ResponseCreatedDocumentFieldCreatedAt        = big.NewInt(1 << 10)
	documentsInit200ResponseCreatedDocumentFieldUpdatedAt        = big.NewInt(1 << 11)
	documentsInit200ResponseCreatedDocumentFieldCreatedBy        = big.NewInt(1 << 12)
)

type DocumentsInit200ResponseCreatedDocument struct {
	ID               string                                                 `json:"id" url:"id"`
	TenantID         string                                                 `json:"tenantId" url:"tenantId"`
	State            DocumentsInit200ResponseCreatedDocumentState           `json:"state" url:"state"`
	BaseSha          *string                                                `json:"baseSha,omitempty" url:"baseSha,omitempty"`
	StorageSizeBytes *float64                                               `json:"storageSizeBytes,omitempty" url:"storageSizeBytes,omitempty"`
	Metadata         map[string]any                                         `json:"metadata,omitempty" url:"metadata,omitempty"`
	IdempotencyKey   *string                                                `json:"idempotencyKey,omitempty" url:"idempotencyKey,omitempty"`
	FailureReason    *string                                                `json:"failureReason,omitempty" url:"failureReason,omitempty"`
	ThumbnailState   *DocumentsInit200ResponseCreatedDocumentThumbnailState `json:"thumbnailState,omitempty" url:"thumbnailState,omitempty"`
	ThumbnailURL     *string                                                `json:"thumbnailUrl,omitempty" url:"thumbnailUrl,omitempty"`
	CreatedAt        float64                                                `json:"createdAt" url:"createdAt"`
	UpdatedAt        float64                                                `json:"updatedAt" url:"updatedAt"`
	CreatedBy        *string                                                `json:"createdBy,omitempty" url:"createdBy,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 (d *DocumentsInit200ResponseCreatedDocument) GetID() string {
	if d == nil {
		return ""
	}
	return d.ID
}

func (d *DocumentsInit200ResponseCreatedDocument) GetTenantID() string {
	if d == nil {
		return ""
	}
	return d.TenantID
}

func (d *DocumentsInit200ResponseCreatedDocument) GetState() DocumentsInit200ResponseCreatedDocumentState {
	if d == nil {
		return ""
	}
	return d.State
}

func (d *DocumentsInit200ResponseCreatedDocument) GetBaseSha() *string {
	if d == nil {
		return nil
	}
	return d.BaseSha
}

func (d *DocumentsInit200ResponseCreatedDocument) GetStorageSizeBytes() *float64 {
	if d == nil {
		return nil
	}
	return d.StorageSizeBytes
}

func (d *DocumentsInit200ResponseCreatedDocument) GetMetadata() map[string]any {
	if d == nil {
		return nil
	}
	return d.Metadata
}

func (d *DocumentsInit200ResponseCreatedDocument) GetIdempotencyKey() *string {
	if d == nil {
		return nil
	}
	return d.IdempotencyKey
}

func (d *DocumentsInit200ResponseCreatedDocument) GetFailureReason() *string {
	if d == nil {
		return nil
	}
	return d.FailureReason
}

func (d *DocumentsInit200ResponseCreatedDocument) GetThumbnailState() *DocumentsInit200ResponseCreatedDocumentThumbnailState {
	if d == nil {
		return nil
	}
	return d.ThumbnailState
}

func (d *DocumentsInit200ResponseCreatedDocument) GetThumbnailURL() *string {
	if d == nil {
		return nil
	}
	return d.ThumbnailURL
}

func (d *DocumentsInit200ResponseCreatedDocument) GetCreatedAt() float64 {
	if d == nil {
		return 0
	}
	return d.CreatedAt
}

func (d *DocumentsInit200ResponseCreatedDocument) GetUpdatedAt() float64 {
	if d == nil {
		return 0
	}
	return d.UpdatedAt
}

func (d *DocumentsInit200ResponseCreatedDocument) GetCreatedBy() *string {
	if d == nil {
		return nil
	}
	return d.CreatedBy
}

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

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

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedDocument) SetTenantID(tenantID string) {
	d.TenantID = tenantID
	d.require(documentsInit200ResponseCreatedDocumentFieldTenantID)
}

// SetState sets the State field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedDocument) SetState(state DocumentsInit200ResponseCreatedDocumentState) {
	d.State = state
	d.require(documentsInit200ResponseCreatedDocumentFieldState)
}

// SetBaseSha sets the BaseSha field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedDocument) SetBaseSha(baseSha *string) {
	d.BaseSha = baseSha
	d.require(documentsInit200ResponseCreatedDocumentFieldBaseSha)
}

// SetStorageSizeBytes sets the StorageSizeBytes field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedDocument) SetStorageSizeBytes(storageSizeBytes *float64) {
	d.StorageSizeBytes = storageSizeBytes
	d.require(documentsInit200ResponseCreatedDocumentFieldStorageSizeBytes)
}

// SetMetadata sets the Metadata field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedDocument) SetMetadata(metadata map[string]any) {
	d.Metadata = metadata
	d.require(documentsInit200ResponseCreatedDocumentFieldMetadata)
}

// SetIdempotencyKey sets the IdempotencyKey field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedDocument) SetIdempotencyKey(idempotencyKey *string) {
	d.IdempotencyKey = idempotencyKey
	d.require(documentsInit200ResponseCreatedDocumentFieldIdempotencyKey)
}

// SetFailureReason sets the FailureReason field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedDocument) SetFailureReason(failureReason *string) {
	d.FailureReason = failureReason
	d.require(documentsInit200ResponseCreatedDocumentFieldFailureReason)
}

// SetThumbnailState sets the ThumbnailState field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedDocument) SetThumbnailState(thumbnailState *DocumentsInit200ResponseCreatedDocumentThumbnailState) {
	d.ThumbnailState = thumbnailState
	d.require(documentsInit200ResponseCreatedDocumentFieldThumbnailState)
}

// SetThumbnailURL sets the ThumbnailURL field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedDocument) SetThumbnailURL(thumbnailURL *string) {
	d.ThumbnailURL = thumbnailURL
	d.require(documentsInit200ResponseCreatedDocumentFieldThumbnailURL)
}

// 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 (d *DocumentsInit200ResponseCreatedDocument) SetCreatedAt(createdAt float64) {
	d.CreatedAt = createdAt
	d.require(documentsInit200ResponseCreatedDocumentFieldCreatedAt)
}

// 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 (d *DocumentsInit200ResponseCreatedDocument) SetUpdatedAt(updatedAt float64) {
	d.UpdatedAt = updatedAt
	d.require(documentsInit200ResponseCreatedDocumentFieldUpdatedAt)
}

// SetCreatedBy sets the CreatedBy field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedDocument) SetCreatedBy(createdBy *string) {
	d.CreatedBy = createdBy
	d.require(documentsInit200ResponseCreatedDocumentFieldCreatedBy)
}

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

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

func (d *DocumentsInit200ResponseCreatedDocument) String() string {
	if d == nil {
		return "<nil>"
	}
	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)
}

type DocumentsInit200ResponseCreatedDocumentState string

const (
	DocumentsInit200ResponseCreatedDocumentStatePending  DocumentsInit200ResponseCreatedDocumentState = "pending"
	DocumentsInit200ResponseCreatedDocumentStateReady    DocumentsInit200ResponseCreatedDocumentState = "ready"
	DocumentsInit200ResponseCreatedDocumentStateFailed   DocumentsInit200ResponseCreatedDocumentState = "failed"
	DocumentsInit200ResponseCreatedDocumentStateDeleting DocumentsInit200ResponseCreatedDocumentState = "deleting"
)

func NewDocumentsInit200ResponseCreatedDocumentStateFromString(s string) (DocumentsInit200ResponseCreatedDocumentState, error) {
	switch s {
	case "pending":
		return DocumentsInit200ResponseCreatedDocumentStatePending, nil
	case "ready":
		return DocumentsInit200ResponseCreatedDocumentStateReady, nil
	case "failed":
		return DocumentsInit200ResponseCreatedDocumentStateFailed, nil
	case "deleting":
		return DocumentsInit200ResponseCreatedDocumentStateDeleting, nil
	}
	var t DocumentsInit200ResponseCreatedDocumentState
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsInit200ResponseCreatedDocumentState) Ptr() *DocumentsInit200ResponseCreatedDocumentState {
	return &d
}

type DocumentsInit200ResponseCreatedDocumentThumbnailState string

const (
	DocumentsInit200ResponseCreatedDocumentThumbnailStatePending DocumentsInit200ResponseCreatedDocumentThumbnailState = "pending"
	DocumentsInit200ResponseCreatedDocumentThumbnailStateReady   DocumentsInit200ResponseCreatedDocumentThumbnailState = "ready"
	DocumentsInit200ResponseCreatedDocumentThumbnailStateLocked  DocumentsInit200ResponseCreatedDocumentThumbnailState = "locked"
	DocumentsInit200ResponseCreatedDocumentThumbnailStateFailed  DocumentsInit200ResponseCreatedDocumentThumbnailState = "failed"
)

func NewDocumentsInit200ResponseCreatedDocumentThumbnailStateFromString(s string) (DocumentsInit200ResponseCreatedDocumentThumbnailState, error) {
	switch s {
	case "pending":
		return DocumentsInit200ResponseCreatedDocumentThumbnailStatePending, nil
	case "ready":
		return DocumentsInit200ResponseCreatedDocumentThumbnailStateReady, nil
	case "locked":
		return DocumentsInit200ResponseCreatedDocumentThumbnailStateLocked, nil
	case "failed":
		return DocumentsInit200ResponseCreatedDocumentThumbnailStateFailed, nil
	}
	var t DocumentsInit200ResponseCreatedDocumentThumbnailState
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsInit200ResponseCreatedDocumentThumbnailState) Ptr() *DocumentsInit200ResponseCreatedDocumentThumbnailState {
	return &d
}

type DocumentsInit200ResponseCreatedUpload struct {
	Kind      string
	Presigned *DocumentsInit200ResponseCreatedUploadPresigned
	Proxy     *DocumentsInit200ResponseCreatedUploadProxy

	rawJSON json.RawMessage
}

func (d *DocumentsInit200ResponseCreatedUpload) GetKind() string {
	if d == nil {
		return ""
	}
	return d.Kind
}

func (d *DocumentsInit200ResponseCreatedUpload) GetPresigned() *DocumentsInit200ResponseCreatedUploadPresigned {
	if d == nil {
		return nil
	}
	return d.Presigned
}

func (d *DocumentsInit200ResponseCreatedUpload) GetProxy() *DocumentsInit200ResponseCreatedUploadProxy {
	if d == nil {
		return nil
	}
	return d.Proxy
}

func (d *DocumentsInit200ResponseCreatedUpload) UnmarshalJSON(data []byte) error {
	var unmarshaler struct {
		Kind string `json:"kind"`
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	d.Kind = unmarshaler.Kind
	if unmarshaler.Kind == "" {
		return fmt.Errorf("%T did not include discriminant kind", d)
	}
	switch unmarshaler.Kind {
	case "presigned":
		value := new(DocumentsInit200ResponseCreatedUploadPresigned)
		if err := json.Unmarshal(data, &value); err != nil {
			return err
		}
		d.Presigned = value
	case "proxy":
		value := new(DocumentsInit200ResponseCreatedUploadProxy)
		if err := json.Unmarshal(data, &value); err != nil {
			return err
		}
		d.Proxy = value
	}
	d.rawJSON = json.RawMessage(data)
	return nil
}

func (d DocumentsInit200ResponseCreatedUpload) MarshalJSON() ([]byte, error) {
	if err := d.validate(); err != nil {
		return nil, err
	}
	if d.Presigned != nil {
		return internal.MarshalJSONWithExtraProperty(d.Presigned, "kind", "presigned")
	}
	if d.Proxy != nil {
		return internal.MarshalJSONWithExtraProperty(d.Proxy, "kind", "proxy")
	}
	if len(d.rawJSON) > 0 {
		return d.rawJSON, nil
	}
	return nil, fmt.Errorf("type %T does not define a non-empty union type", d)
}

type DocumentsInit200ResponseCreatedUploadVisitor interface {
	VisitPresigned(*DocumentsInit200ResponseCreatedUploadPresigned) error
	VisitProxy(*DocumentsInit200ResponseCreatedUploadProxy) error
}

func (d *DocumentsInit200ResponseCreatedUpload) Accept(visitor DocumentsInit200ResponseCreatedUploadVisitor) error {
	if d.Presigned != nil {
		return visitor.VisitPresigned(d.Presigned)
	}
	if d.Proxy != nil {
		return visitor.VisitProxy(d.Proxy)
	}
	return fmt.Errorf("type %T does not define a non-empty union type", d)
}

func (d *DocumentsInit200ResponseCreatedUpload) validate() error {
	if d == nil {
		return fmt.Errorf("type %T is nil", d)
	}
	var fields []string
	if d.Presigned != nil {
		fields = append(fields, "presigned")
	}
	if d.Proxy != nil {
		fields = append(fields, "proxy")
	}
	if len(fields) == 0 {
		if d.Kind != "" {
			if len(d.rawJSON) > 0 {
				return nil
			}
			return fmt.Errorf("type %T defines a discriminant set to %q but the field is not set", d, d.Kind)
		}
		return fmt.Errorf("type %T is empty", d)
	}
	if len(fields) > 1 {
		return fmt.Errorf("type %T defines values for %s, but only one value is allowed", d, fields)
	}
	if d.Kind != "" {
		field := fields[0]
		if d.Kind != field {
			return fmt.Errorf(
				"type %T defines a discriminant set to %q, but it does not match the %T field; either remove or update the discriminant to match",
				d,
				d.Kind,
				d,
			)
		}
	}
	return nil
}

var (
	documentsInit200ResponseCreatedUploadPresignedFieldPresigned = big.NewInt(1 << 0)
	documentsInit200ResponseCreatedUploadPresignedFieldKey       = big.NewInt(1 << 1)
)

type DocumentsInit200ResponseCreatedUploadPresigned struct {
	Presigned *DocumentsInit200ResponseCreatedUploadPresignedPresigned `json:"presigned" url:"presigned"`
	Key       string                                                   `json:"key" url:"key"`

	// 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 *DocumentsInit200ResponseCreatedUploadPresigned) GetPresigned() *DocumentsInit200ResponseCreatedUploadPresignedPresigned {
	if d == nil {
		return nil
	}
	return d.Presigned
}

func (d *DocumentsInit200ResponseCreatedUploadPresigned) GetKey() string {
	if d == nil {
		return ""
	}
	return d.Key
}

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

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

// SetPresigned sets the Presigned field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedUploadPresigned) SetPresigned(presigned *DocumentsInit200ResponseCreatedUploadPresignedPresigned) {
	d.Presigned = presigned
	d.require(documentsInit200ResponseCreatedUploadPresignedFieldPresigned)
}

// SetKey sets the Key field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedUploadPresigned) SetKey(key string) {
	d.Key = key
	d.require(documentsInit200ResponseCreatedUploadPresignedFieldKey)
}

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

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

func (d *DocumentsInit200ResponseCreatedUploadPresigned) String() string {
	if d == nil {
		return "<nil>"
	}
	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 (
	documentsInit200ResponseCreatedUploadPresignedPresignedFieldURL       = big.NewInt(1 << 0)
	documentsInit200ResponseCreatedUploadPresignedPresignedFieldHeaders   = big.NewInt(1 << 1)
	documentsInit200ResponseCreatedUploadPresignedPresignedFieldMethod    = big.NewInt(1 << 2)
	documentsInit200ResponseCreatedUploadPresignedPresignedFieldExpiresAt = big.NewInt(1 << 3)
)

type DocumentsInit200ResponseCreatedUploadPresignedPresigned struct {
	URL       string                                                        `json:"url" url:"url"`
	Headers   map[string]string                                             `json:"headers" url:"headers"`
	Method    DocumentsInit200ResponseCreatedUploadPresignedPresignedMethod `json:"method" url:"method"`
	ExpiresAt float64                                                       `json:"expiresAt" url:"expiresAt"`

	// 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 *DocumentsInit200ResponseCreatedUploadPresignedPresigned) GetURL() string {
	if d == nil {
		return ""
	}
	return d.URL
}

func (d *DocumentsInit200ResponseCreatedUploadPresignedPresigned) GetHeaders() map[string]string {
	if d == nil {
		return nil
	}
	return d.Headers
}

func (d *DocumentsInit200ResponseCreatedUploadPresignedPresigned) GetMethod() DocumentsInit200ResponseCreatedUploadPresignedPresignedMethod {
	if d == nil {
		return ""
	}
	return d.Method
}

func (d *DocumentsInit200ResponseCreatedUploadPresignedPresigned) GetExpiresAt() float64 {
	if d == nil {
		return 0
	}
	return d.ExpiresAt
}

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

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

// SetURL sets the URL field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedUploadPresignedPresigned) SetURL(url string) {
	d.URL = url
	d.require(documentsInit200ResponseCreatedUploadPresignedPresignedFieldURL)
}

// SetHeaders sets the Headers field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedUploadPresignedPresigned) SetHeaders(headers map[string]string) {
	d.Headers = headers
	d.require(documentsInit200ResponseCreatedUploadPresignedPresignedFieldHeaders)
}

// SetMethod sets the Method field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedUploadPresignedPresigned) SetMethod(method DocumentsInit200ResponseCreatedUploadPresignedPresignedMethod) {
	d.Method = method
	d.require(documentsInit200ResponseCreatedUploadPresignedPresignedFieldMethod)
}

// SetExpiresAt sets the ExpiresAt field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedUploadPresignedPresigned) SetExpiresAt(expiresAt float64) {
	d.ExpiresAt = expiresAt
	d.require(documentsInit200ResponseCreatedUploadPresignedPresignedFieldExpiresAt)
}

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

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

func (d *DocumentsInit200ResponseCreatedUploadPresignedPresigned) String() string {
	if d == nil {
		return "<nil>"
	}
	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)
}

type DocumentsInit200ResponseCreatedUploadPresignedPresignedMethod string

const (
	DocumentsInit200ResponseCreatedUploadPresignedPresignedMethodPut DocumentsInit200ResponseCreatedUploadPresignedPresignedMethod = "PUT"
)

func NewDocumentsInit200ResponseCreatedUploadPresignedPresignedMethodFromString(s string) (DocumentsInit200ResponseCreatedUploadPresignedPresignedMethod, error) {
	switch s {
	case "PUT":
		return DocumentsInit200ResponseCreatedUploadPresignedPresignedMethodPut, nil
	}
	var t DocumentsInit200ResponseCreatedUploadPresignedPresignedMethod
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsInit200ResponseCreatedUploadPresignedPresignedMethod) Ptr() *DocumentsInit200ResponseCreatedUploadPresignedPresignedMethod {
	return &d
}

var (
	documentsInit200ResponseCreatedUploadProxyFieldURL = big.NewInt(1 << 0)
	documentsInit200ResponseCreatedUploadProxyFieldKey = big.NewInt(1 << 1)
)

type DocumentsInit200ResponseCreatedUploadProxy struct {
	URL string `json:"url" url:"url"`
	Key string `json:"key" url:"key"`

	// 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 *DocumentsInit200ResponseCreatedUploadProxy) GetURL() string {
	if d == nil {
		return ""
	}
	return d.URL
}

func (d *DocumentsInit200ResponseCreatedUploadProxy) GetKey() string {
	if d == nil {
		return ""
	}
	return d.Key
}

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

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

// SetURL sets the URL field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedUploadProxy) SetURL(url string) {
	d.URL = url
	d.require(documentsInit200ResponseCreatedUploadProxyFieldURL)
}

// SetKey sets the Key field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseCreatedUploadProxy) SetKey(key string) {
	d.Key = key
	d.require(documentsInit200ResponseCreatedUploadProxyFieldKey)
}

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

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

func (d *DocumentsInit200ResponseCreatedUploadProxy) String() string {
	if d == nil {
		return "<nil>"
	}
	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 (
	documentsInit200ResponseDedupedFieldDocument = big.NewInt(1 << 0)
)

type DocumentsInit200ResponseDeduped struct {
	Document *DocumentsInit200ResponseDedupedDocument `json:"document" url:"document"`

	// 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 *DocumentsInit200ResponseDeduped) GetDocument() *DocumentsInit200ResponseDedupedDocument {
	if d == nil {
		return nil
	}
	return d.Document
}

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

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

// SetDocument sets the Document field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseDeduped) SetDocument(document *DocumentsInit200ResponseDedupedDocument) {
	d.Document = document
	d.require(documentsInit200ResponseDedupedFieldDocument)
}

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

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

func (d *DocumentsInit200ResponseDeduped) String() string {
	if d == nil {
		return "<nil>"
	}
	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 (
	documentsInit200ResponseDedupedDocumentFieldID               = big.NewInt(1 << 0)
	documentsInit200ResponseDedupedDocumentFieldTenantID         = big.NewInt(1 << 1)
	documentsInit200ResponseDedupedDocumentFieldState            = big.NewInt(1 << 2)
	documentsInit200ResponseDedupedDocumentFieldBaseSha          = big.NewInt(1 << 3)
	documentsInit200ResponseDedupedDocumentFieldStorageSizeBytes = big.NewInt(1 << 4)
	documentsInit200ResponseDedupedDocumentFieldMetadata         = big.NewInt(1 << 5)
	documentsInit200ResponseDedupedDocumentFieldIdempotencyKey   = big.NewInt(1 << 6)
	documentsInit200ResponseDedupedDocumentFieldFailureReason    = big.NewInt(1 << 7)
	documentsInit200ResponseDedupedDocumentFieldThumbnailState   = big.NewInt(1 << 8)
	documentsInit200ResponseDedupedDocumentFieldThumbnailURL     = big.NewInt(1 << 9)
	documentsInit200ResponseDedupedDocumentFieldCreatedAt        = big.NewInt(1 << 10)
	documentsInit200ResponseDedupedDocumentFieldUpdatedAt        = big.NewInt(1 << 11)
	documentsInit200ResponseDedupedDocumentFieldCreatedBy        = big.NewInt(1 << 12)
)

type DocumentsInit200ResponseDedupedDocument struct {
	ID               string                                                 `json:"id" url:"id"`
	TenantID         string                                                 `json:"tenantId" url:"tenantId"`
	State            DocumentsInit200ResponseDedupedDocumentState           `json:"state" url:"state"`
	BaseSha          *string                                                `json:"baseSha,omitempty" url:"baseSha,omitempty"`
	StorageSizeBytes *float64                                               `json:"storageSizeBytes,omitempty" url:"storageSizeBytes,omitempty"`
	Metadata         map[string]any                                         `json:"metadata,omitempty" url:"metadata,omitempty"`
	IdempotencyKey   *string                                                `json:"idempotencyKey,omitempty" url:"idempotencyKey,omitempty"`
	FailureReason    *string                                                `json:"failureReason,omitempty" url:"failureReason,omitempty"`
	ThumbnailState   *DocumentsInit200ResponseDedupedDocumentThumbnailState `json:"thumbnailState,omitempty" url:"thumbnailState,omitempty"`
	ThumbnailURL     *string                                                `json:"thumbnailUrl,omitempty" url:"thumbnailUrl,omitempty"`
	CreatedAt        float64                                                `json:"createdAt" url:"createdAt"`
	UpdatedAt        float64                                                `json:"updatedAt" url:"updatedAt"`
	CreatedBy        *string                                                `json:"createdBy,omitempty" url:"createdBy,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 (d *DocumentsInit200ResponseDedupedDocument) GetID() string {
	if d == nil {
		return ""
	}
	return d.ID
}

func (d *DocumentsInit200ResponseDedupedDocument) GetTenantID() string {
	if d == nil {
		return ""
	}
	return d.TenantID
}

func (d *DocumentsInit200ResponseDedupedDocument) GetState() DocumentsInit200ResponseDedupedDocumentState {
	if d == nil {
		return ""
	}
	return d.State
}

func (d *DocumentsInit200ResponseDedupedDocument) GetBaseSha() *string {
	if d == nil {
		return nil
	}
	return d.BaseSha
}

func (d *DocumentsInit200ResponseDedupedDocument) GetStorageSizeBytes() *float64 {
	if d == nil {
		return nil
	}
	return d.StorageSizeBytes
}

func (d *DocumentsInit200ResponseDedupedDocument) GetMetadata() map[string]any {
	if d == nil {
		return nil
	}
	return d.Metadata
}

func (d *DocumentsInit200ResponseDedupedDocument) GetIdempotencyKey() *string {
	if d == nil {
		return nil
	}
	return d.IdempotencyKey
}

func (d *DocumentsInit200ResponseDedupedDocument) GetFailureReason() *string {
	if d == nil {
		return nil
	}
	return d.FailureReason
}

func (d *DocumentsInit200ResponseDedupedDocument) GetThumbnailState() *DocumentsInit200ResponseDedupedDocumentThumbnailState {
	if d == nil {
		return nil
	}
	return d.ThumbnailState
}

func (d *DocumentsInit200ResponseDedupedDocument) GetThumbnailURL() *string {
	if d == nil {
		return nil
	}
	return d.ThumbnailURL
}

func (d *DocumentsInit200ResponseDedupedDocument) GetCreatedAt() float64 {
	if d == nil {
		return 0
	}
	return d.CreatedAt
}

func (d *DocumentsInit200ResponseDedupedDocument) GetUpdatedAt() float64 {
	if d == nil {
		return 0
	}
	return d.UpdatedAt
}

func (d *DocumentsInit200ResponseDedupedDocument) GetCreatedBy() *string {
	if d == nil {
		return nil
	}
	return d.CreatedBy
}

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

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

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseDedupedDocument) SetTenantID(tenantID string) {
	d.TenantID = tenantID
	d.require(documentsInit200ResponseDedupedDocumentFieldTenantID)
}

// SetState sets the State field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseDedupedDocument) SetState(state DocumentsInit200ResponseDedupedDocumentState) {
	d.State = state
	d.require(documentsInit200ResponseDedupedDocumentFieldState)
}

// SetBaseSha sets the BaseSha field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseDedupedDocument) SetBaseSha(baseSha *string) {
	d.BaseSha = baseSha
	d.require(documentsInit200ResponseDedupedDocumentFieldBaseSha)
}

// SetStorageSizeBytes sets the StorageSizeBytes field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseDedupedDocument) SetStorageSizeBytes(storageSizeBytes *float64) {
	d.StorageSizeBytes = storageSizeBytes
	d.require(documentsInit200ResponseDedupedDocumentFieldStorageSizeBytes)
}

// SetMetadata sets the Metadata field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseDedupedDocument) SetMetadata(metadata map[string]any) {
	d.Metadata = metadata
	d.require(documentsInit200ResponseDedupedDocumentFieldMetadata)
}

// SetIdempotencyKey sets the IdempotencyKey field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseDedupedDocument) SetIdempotencyKey(idempotencyKey *string) {
	d.IdempotencyKey = idempotencyKey
	d.require(documentsInit200ResponseDedupedDocumentFieldIdempotencyKey)
}

// SetFailureReason sets the FailureReason field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseDedupedDocument) SetFailureReason(failureReason *string) {
	d.FailureReason = failureReason
	d.require(documentsInit200ResponseDedupedDocumentFieldFailureReason)
}

// SetThumbnailState sets the ThumbnailState field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseDedupedDocument) SetThumbnailState(thumbnailState *DocumentsInit200ResponseDedupedDocumentThumbnailState) {
	d.ThumbnailState = thumbnailState
	d.require(documentsInit200ResponseDedupedDocumentFieldThumbnailState)
}

// SetThumbnailURL sets the ThumbnailURL field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseDedupedDocument) SetThumbnailURL(thumbnailURL *string) {
	d.ThumbnailURL = thumbnailURL
	d.require(documentsInit200ResponseDedupedDocumentFieldThumbnailURL)
}

// 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 (d *DocumentsInit200ResponseDedupedDocument) SetCreatedAt(createdAt float64) {
	d.CreatedAt = createdAt
	d.require(documentsInit200ResponseDedupedDocumentFieldCreatedAt)
}

// 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 (d *DocumentsInit200ResponseDedupedDocument) SetUpdatedAt(updatedAt float64) {
	d.UpdatedAt = updatedAt
	d.require(documentsInit200ResponseDedupedDocumentFieldUpdatedAt)
}

// SetCreatedBy sets the CreatedBy field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseDedupedDocument) SetCreatedBy(createdBy *string) {
	d.CreatedBy = createdBy
	d.require(documentsInit200ResponseDedupedDocumentFieldCreatedBy)
}

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

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

func (d *DocumentsInit200ResponseDedupedDocument) String() string {
	if d == nil {
		return "<nil>"
	}
	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)
}

type DocumentsInit200ResponseDedupedDocumentState string

const (
	DocumentsInit200ResponseDedupedDocumentStatePending  DocumentsInit200ResponseDedupedDocumentState = "pending"
	DocumentsInit200ResponseDedupedDocumentStateReady    DocumentsInit200ResponseDedupedDocumentState = "ready"
	DocumentsInit200ResponseDedupedDocumentStateFailed   DocumentsInit200ResponseDedupedDocumentState = "failed"
	DocumentsInit200ResponseDedupedDocumentStateDeleting DocumentsInit200ResponseDedupedDocumentState = "deleting"
)

func NewDocumentsInit200ResponseDedupedDocumentStateFromString(s string) (DocumentsInit200ResponseDedupedDocumentState, error) {
	switch s {
	case "pending":
		return DocumentsInit200ResponseDedupedDocumentStatePending, nil
	case "ready":
		return DocumentsInit200ResponseDedupedDocumentStateReady, nil
	case "failed":
		return DocumentsInit200ResponseDedupedDocumentStateFailed, nil
	case "deleting":
		return DocumentsInit200ResponseDedupedDocumentStateDeleting, nil
	}
	var t DocumentsInit200ResponseDedupedDocumentState
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsInit200ResponseDedupedDocumentState) Ptr() *DocumentsInit200ResponseDedupedDocumentState {
	return &d
}

type DocumentsInit200ResponseDedupedDocumentThumbnailState string

const (
	DocumentsInit200ResponseDedupedDocumentThumbnailStatePending DocumentsInit200ResponseDedupedDocumentThumbnailState = "pending"
	DocumentsInit200ResponseDedupedDocumentThumbnailStateReady   DocumentsInit200ResponseDedupedDocumentThumbnailState = "ready"
	DocumentsInit200ResponseDedupedDocumentThumbnailStateLocked  DocumentsInit200ResponseDedupedDocumentThumbnailState = "locked"
	DocumentsInit200ResponseDedupedDocumentThumbnailStateFailed  DocumentsInit200ResponseDedupedDocumentThumbnailState = "failed"
)

func NewDocumentsInit200ResponseDedupedDocumentThumbnailStateFromString(s string) (DocumentsInit200ResponseDedupedDocumentThumbnailState, error) {
	switch s {
	case "pending":
		return DocumentsInit200ResponseDedupedDocumentThumbnailStatePending, nil
	case "ready":
		return DocumentsInit200ResponseDedupedDocumentThumbnailStateReady, nil
	case "locked":
		return DocumentsInit200ResponseDedupedDocumentThumbnailStateLocked, nil
	case "failed":
		return DocumentsInit200ResponseDedupedDocumentThumbnailStateFailed, nil
	}
	var t DocumentsInit200ResponseDedupedDocumentThumbnailState
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsInit200ResponseDedupedDocumentThumbnailState) Ptr() *DocumentsInit200ResponseDedupedDocumentThumbnailState {
	return &d
}

var (
	documentsInit200ResponseResumedFieldDocument = big.NewInt(1 << 0)
	documentsInit200ResponseResumedFieldUpload   = big.NewInt(1 << 1)
)

type DocumentsInit200ResponseResumed struct {
	Document *DocumentsInit200ResponseResumedDocument `json:"document" url:"document"`
	Upload   *DocumentsInit200ResponseResumedUpload   `json:"upload" url:"upload"`

	// 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 *DocumentsInit200ResponseResumed) GetDocument() *DocumentsInit200ResponseResumedDocument {
	if d == nil {
		return nil
	}
	return d.Document
}

func (d *DocumentsInit200ResponseResumed) GetUpload() *DocumentsInit200ResponseResumedUpload {
	if d == nil {
		return nil
	}
	return d.Upload
}

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

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

// SetDocument sets the Document field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumed) SetDocument(document *DocumentsInit200ResponseResumedDocument) {
	d.Document = document
	d.require(documentsInit200ResponseResumedFieldDocument)
}

// SetUpload sets the Upload field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumed) SetUpload(upload *DocumentsInit200ResponseResumedUpload) {
	d.Upload = upload
	d.require(documentsInit200ResponseResumedFieldUpload)
}

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

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

func (d *DocumentsInit200ResponseResumed) String() string {
	if d == nil {
		return "<nil>"
	}
	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 (
	documentsInit200ResponseResumedDocumentFieldID               = big.NewInt(1 << 0)
	documentsInit200ResponseResumedDocumentFieldTenantID         = big.NewInt(1 << 1)
	documentsInit200ResponseResumedDocumentFieldState            = big.NewInt(1 << 2)
	documentsInit200ResponseResumedDocumentFieldBaseSha          = big.NewInt(1 << 3)
	documentsInit200ResponseResumedDocumentFieldStorageSizeBytes = big.NewInt(1 << 4)
	documentsInit200ResponseResumedDocumentFieldMetadata         = big.NewInt(1 << 5)
	documentsInit200ResponseResumedDocumentFieldIdempotencyKey   = big.NewInt(1 << 6)
	documentsInit200ResponseResumedDocumentFieldFailureReason    = big.NewInt(1 << 7)
	documentsInit200ResponseResumedDocumentFieldThumbnailState   = big.NewInt(1 << 8)
	documentsInit200ResponseResumedDocumentFieldThumbnailURL     = big.NewInt(1 << 9)
	documentsInit200ResponseResumedDocumentFieldCreatedAt        = big.NewInt(1 << 10)
	documentsInit200ResponseResumedDocumentFieldUpdatedAt        = big.NewInt(1 << 11)
	documentsInit200ResponseResumedDocumentFieldCreatedBy        = big.NewInt(1 << 12)
)

type DocumentsInit200ResponseResumedDocument struct {
	ID               string                                                 `json:"id" url:"id"`
	TenantID         string                                                 `json:"tenantId" url:"tenantId"`
	State            DocumentsInit200ResponseResumedDocumentState           `json:"state" url:"state"`
	BaseSha          *string                                                `json:"baseSha,omitempty" url:"baseSha,omitempty"`
	StorageSizeBytes *float64                                               `json:"storageSizeBytes,omitempty" url:"storageSizeBytes,omitempty"`
	Metadata         map[string]any                                         `json:"metadata,omitempty" url:"metadata,omitempty"`
	IdempotencyKey   *string                                                `json:"idempotencyKey,omitempty" url:"idempotencyKey,omitempty"`
	FailureReason    *string                                                `json:"failureReason,omitempty" url:"failureReason,omitempty"`
	ThumbnailState   *DocumentsInit200ResponseResumedDocumentThumbnailState `json:"thumbnailState,omitempty" url:"thumbnailState,omitempty"`
	ThumbnailURL     *string                                                `json:"thumbnailUrl,omitempty" url:"thumbnailUrl,omitempty"`
	CreatedAt        float64                                                `json:"createdAt" url:"createdAt"`
	UpdatedAt        float64                                                `json:"updatedAt" url:"updatedAt"`
	CreatedBy        *string                                                `json:"createdBy,omitempty" url:"createdBy,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 (d *DocumentsInit200ResponseResumedDocument) GetID() string {
	if d == nil {
		return ""
	}
	return d.ID
}

func (d *DocumentsInit200ResponseResumedDocument) GetTenantID() string {
	if d == nil {
		return ""
	}
	return d.TenantID
}

func (d *DocumentsInit200ResponseResumedDocument) GetState() DocumentsInit200ResponseResumedDocumentState {
	if d == nil {
		return ""
	}
	return d.State
}

func (d *DocumentsInit200ResponseResumedDocument) GetBaseSha() *string {
	if d == nil {
		return nil
	}
	return d.BaseSha
}

func (d *DocumentsInit200ResponseResumedDocument) GetStorageSizeBytes() *float64 {
	if d == nil {
		return nil
	}
	return d.StorageSizeBytes
}

func (d *DocumentsInit200ResponseResumedDocument) GetMetadata() map[string]any {
	if d == nil {
		return nil
	}
	return d.Metadata
}

func (d *DocumentsInit200ResponseResumedDocument) GetIdempotencyKey() *string {
	if d == nil {
		return nil
	}
	return d.IdempotencyKey
}

func (d *DocumentsInit200ResponseResumedDocument) GetFailureReason() *string {
	if d == nil {
		return nil
	}
	return d.FailureReason
}

func (d *DocumentsInit200ResponseResumedDocument) GetThumbnailState() *DocumentsInit200ResponseResumedDocumentThumbnailState {
	if d == nil {
		return nil
	}
	return d.ThumbnailState
}

func (d *DocumentsInit200ResponseResumedDocument) GetThumbnailURL() *string {
	if d == nil {
		return nil
	}
	return d.ThumbnailURL
}

func (d *DocumentsInit200ResponseResumedDocument) GetCreatedAt() float64 {
	if d == nil {
		return 0
	}
	return d.CreatedAt
}

func (d *DocumentsInit200ResponseResumedDocument) GetUpdatedAt() float64 {
	if d == nil {
		return 0
	}
	return d.UpdatedAt
}

func (d *DocumentsInit200ResponseResumedDocument) GetCreatedBy() *string {
	if d == nil {
		return nil
	}
	return d.CreatedBy
}

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

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

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedDocument) SetTenantID(tenantID string) {
	d.TenantID = tenantID
	d.require(documentsInit200ResponseResumedDocumentFieldTenantID)
}

// SetState sets the State field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedDocument) SetState(state DocumentsInit200ResponseResumedDocumentState) {
	d.State = state
	d.require(documentsInit200ResponseResumedDocumentFieldState)
}

// SetBaseSha sets the BaseSha field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedDocument) SetBaseSha(baseSha *string) {
	d.BaseSha = baseSha
	d.require(documentsInit200ResponseResumedDocumentFieldBaseSha)
}

// SetStorageSizeBytes sets the StorageSizeBytes field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedDocument) SetStorageSizeBytes(storageSizeBytes *float64) {
	d.StorageSizeBytes = storageSizeBytes
	d.require(documentsInit200ResponseResumedDocumentFieldStorageSizeBytes)
}

// SetMetadata sets the Metadata field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedDocument) SetMetadata(metadata map[string]any) {
	d.Metadata = metadata
	d.require(documentsInit200ResponseResumedDocumentFieldMetadata)
}

// SetIdempotencyKey sets the IdempotencyKey field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedDocument) SetIdempotencyKey(idempotencyKey *string) {
	d.IdempotencyKey = idempotencyKey
	d.require(documentsInit200ResponseResumedDocumentFieldIdempotencyKey)
}

// SetFailureReason sets the FailureReason field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedDocument) SetFailureReason(failureReason *string) {
	d.FailureReason = failureReason
	d.require(documentsInit200ResponseResumedDocumentFieldFailureReason)
}

// SetThumbnailState sets the ThumbnailState field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedDocument) SetThumbnailState(thumbnailState *DocumentsInit200ResponseResumedDocumentThumbnailState) {
	d.ThumbnailState = thumbnailState
	d.require(documentsInit200ResponseResumedDocumentFieldThumbnailState)
}

// SetThumbnailURL sets the ThumbnailURL field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedDocument) SetThumbnailURL(thumbnailURL *string) {
	d.ThumbnailURL = thumbnailURL
	d.require(documentsInit200ResponseResumedDocumentFieldThumbnailURL)
}

// 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 (d *DocumentsInit200ResponseResumedDocument) SetCreatedAt(createdAt float64) {
	d.CreatedAt = createdAt
	d.require(documentsInit200ResponseResumedDocumentFieldCreatedAt)
}

// 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 (d *DocumentsInit200ResponseResumedDocument) SetUpdatedAt(updatedAt float64) {
	d.UpdatedAt = updatedAt
	d.require(documentsInit200ResponseResumedDocumentFieldUpdatedAt)
}

// SetCreatedBy sets the CreatedBy field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedDocument) SetCreatedBy(createdBy *string) {
	d.CreatedBy = createdBy
	d.require(documentsInit200ResponseResumedDocumentFieldCreatedBy)
}

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

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

func (d *DocumentsInit200ResponseResumedDocument) String() string {
	if d == nil {
		return "<nil>"
	}
	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)
}

type DocumentsInit200ResponseResumedDocumentState string

const (
	DocumentsInit200ResponseResumedDocumentStatePending  DocumentsInit200ResponseResumedDocumentState = "pending"
	DocumentsInit200ResponseResumedDocumentStateReady    DocumentsInit200ResponseResumedDocumentState = "ready"
	DocumentsInit200ResponseResumedDocumentStateFailed   DocumentsInit200ResponseResumedDocumentState = "failed"
	DocumentsInit200ResponseResumedDocumentStateDeleting DocumentsInit200ResponseResumedDocumentState = "deleting"
)

func NewDocumentsInit200ResponseResumedDocumentStateFromString(s string) (DocumentsInit200ResponseResumedDocumentState, error) {
	switch s {
	case "pending":
		return DocumentsInit200ResponseResumedDocumentStatePending, nil
	case "ready":
		return DocumentsInit200ResponseResumedDocumentStateReady, nil
	case "failed":
		return DocumentsInit200ResponseResumedDocumentStateFailed, nil
	case "deleting":
		return DocumentsInit200ResponseResumedDocumentStateDeleting, nil
	}
	var t DocumentsInit200ResponseResumedDocumentState
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsInit200ResponseResumedDocumentState) Ptr() *DocumentsInit200ResponseResumedDocumentState {
	return &d
}

type DocumentsInit200ResponseResumedDocumentThumbnailState string

const (
	DocumentsInit200ResponseResumedDocumentThumbnailStatePending DocumentsInit200ResponseResumedDocumentThumbnailState = "pending"
	DocumentsInit200ResponseResumedDocumentThumbnailStateReady   DocumentsInit200ResponseResumedDocumentThumbnailState = "ready"
	DocumentsInit200ResponseResumedDocumentThumbnailStateLocked  DocumentsInit200ResponseResumedDocumentThumbnailState = "locked"
	DocumentsInit200ResponseResumedDocumentThumbnailStateFailed  DocumentsInit200ResponseResumedDocumentThumbnailState = "failed"
)

func NewDocumentsInit200ResponseResumedDocumentThumbnailStateFromString(s string) (DocumentsInit200ResponseResumedDocumentThumbnailState, error) {
	switch s {
	case "pending":
		return DocumentsInit200ResponseResumedDocumentThumbnailStatePending, nil
	case "ready":
		return DocumentsInit200ResponseResumedDocumentThumbnailStateReady, nil
	case "locked":
		return DocumentsInit200ResponseResumedDocumentThumbnailStateLocked, nil
	case "failed":
		return DocumentsInit200ResponseResumedDocumentThumbnailStateFailed, nil
	}
	var t DocumentsInit200ResponseResumedDocumentThumbnailState
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsInit200ResponseResumedDocumentThumbnailState) Ptr() *DocumentsInit200ResponseResumedDocumentThumbnailState {
	return &d
}

type DocumentsInit200ResponseResumedUpload struct {
	Kind      string
	Presigned *DocumentsInit200ResponseResumedUploadPresigned
	Proxy     *DocumentsInit200ResponseResumedUploadProxy

	rawJSON json.RawMessage
}

func (d *DocumentsInit200ResponseResumedUpload) GetKind() string {
	if d == nil {
		return ""
	}
	return d.Kind
}

func (d *DocumentsInit200ResponseResumedUpload) GetPresigned() *DocumentsInit200ResponseResumedUploadPresigned {
	if d == nil {
		return nil
	}
	return d.Presigned
}

func (d *DocumentsInit200ResponseResumedUpload) GetProxy() *DocumentsInit200ResponseResumedUploadProxy {
	if d == nil {
		return nil
	}
	return d.Proxy
}

func (d *DocumentsInit200ResponseResumedUpload) UnmarshalJSON(data []byte) error {
	var unmarshaler struct {
		Kind string `json:"kind"`
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	d.Kind = unmarshaler.Kind
	if unmarshaler.Kind == "" {
		return fmt.Errorf("%T did not include discriminant kind", d)
	}
	switch unmarshaler.Kind {
	case "presigned":
		value := new(DocumentsInit200ResponseResumedUploadPresigned)
		if err := json.Unmarshal(data, &value); err != nil {
			return err
		}
		d.Presigned = value
	case "proxy":
		value := new(DocumentsInit200ResponseResumedUploadProxy)
		if err := json.Unmarshal(data, &value); err != nil {
			return err
		}
		d.Proxy = value
	}
	d.rawJSON = json.RawMessage(data)
	return nil
}

func (d DocumentsInit200ResponseResumedUpload) MarshalJSON() ([]byte, error) {
	if err := d.validate(); err != nil {
		return nil, err
	}
	if d.Presigned != nil {
		return internal.MarshalJSONWithExtraProperty(d.Presigned, "kind", "presigned")
	}
	if d.Proxy != nil {
		return internal.MarshalJSONWithExtraProperty(d.Proxy, "kind", "proxy")
	}
	if len(d.rawJSON) > 0 {
		return d.rawJSON, nil
	}
	return nil, fmt.Errorf("type %T does not define a non-empty union type", d)
}

type DocumentsInit200ResponseResumedUploadVisitor interface {
	VisitPresigned(*DocumentsInit200ResponseResumedUploadPresigned) error
	VisitProxy(*DocumentsInit200ResponseResumedUploadProxy) error
}

func (d *DocumentsInit200ResponseResumedUpload) Accept(visitor DocumentsInit200ResponseResumedUploadVisitor) error {
	if d.Presigned != nil {
		return visitor.VisitPresigned(d.Presigned)
	}
	if d.Proxy != nil {
		return visitor.VisitProxy(d.Proxy)
	}
	return fmt.Errorf("type %T does not define a non-empty union type", d)
}

func (d *DocumentsInit200ResponseResumedUpload) validate() error {
	if d == nil {
		return fmt.Errorf("type %T is nil", d)
	}
	var fields []string
	if d.Presigned != nil {
		fields = append(fields, "presigned")
	}
	if d.Proxy != nil {
		fields = append(fields, "proxy")
	}
	if len(fields) == 0 {
		if d.Kind != "" {
			if len(d.rawJSON) > 0 {
				return nil
			}
			return fmt.Errorf("type %T defines a discriminant set to %q but the field is not set", d, d.Kind)
		}
		return fmt.Errorf("type %T is empty", d)
	}
	if len(fields) > 1 {
		return fmt.Errorf("type %T defines values for %s, but only one value is allowed", d, fields)
	}
	if d.Kind != "" {
		field := fields[0]
		if d.Kind != field {
			return fmt.Errorf(
				"type %T defines a discriminant set to %q, but it does not match the %T field; either remove or update the discriminant to match",
				d,
				d.Kind,
				d,
			)
		}
	}
	return nil
}

var (
	documentsInit200ResponseResumedUploadPresignedFieldPresigned = big.NewInt(1 << 0)
	documentsInit200ResponseResumedUploadPresignedFieldKey       = big.NewInt(1 << 1)
)

type DocumentsInit200ResponseResumedUploadPresigned struct {
	Presigned *DocumentsInit200ResponseResumedUploadPresignedPresigned `json:"presigned" url:"presigned"`
	Key       string                                                   `json:"key" url:"key"`

	// 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 *DocumentsInit200ResponseResumedUploadPresigned) GetPresigned() *DocumentsInit200ResponseResumedUploadPresignedPresigned {
	if d == nil {
		return nil
	}
	return d.Presigned
}

func (d *DocumentsInit200ResponseResumedUploadPresigned) GetKey() string {
	if d == nil {
		return ""
	}
	return d.Key
}

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

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

// SetPresigned sets the Presigned field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedUploadPresigned) SetPresigned(presigned *DocumentsInit200ResponseResumedUploadPresignedPresigned) {
	d.Presigned = presigned
	d.require(documentsInit200ResponseResumedUploadPresignedFieldPresigned)
}

// SetKey sets the Key field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedUploadPresigned) SetKey(key string) {
	d.Key = key
	d.require(documentsInit200ResponseResumedUploadPresignedFieldKey)
}

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

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

func (d *DocumentsInit200ResponseResumedUploadPresigned) String() string {
	if d == nil {
		return "<nil>"
	}
	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 (
	documentsInit200ResponseResumedUploadPresignedPresignedFieldURL       = big.NewInt(1 << 0)
	documentsInit200ResponseResumedUploadPresignedPresignedFieldHeaders   = big.NewInt(1 << 1)
	documentsInit200ResponseResumedUploadPresignedPresignedFieldMethod    = big.NewInt(1 << 2)
	documentsInit200ResponseResumedUploadPresignedPresignedFieldExpiresAt = big.NewInt(1 << 3)
)

type DocumentsInit200ResponseResumedUploadPresignedPresigned struct {
	URL       string                                                        `json:"url" url:"url"`
	Headers   map[string]string                                             `json:"headers" url:"headers"`
	Method    DocumentsInit200ResponseResumedUploadPresignedPresignedMethod `json:"method" url:"method"`
	ExpiresAt float64                                                       `json:"expiresAt" url:"expiresAt"`

	// 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 *DocumentsInit200ResponseResumedUploadPresignedPresigned) GetURL() string {
	if d == nil {
		return ""
	}
	return d.URL
}

func (d *DocumentsInit200ResponseResumedUploadPresignedPresigned) GetHeaders() map[string]string {
	if d == nil {
		return nil
	}
	return d.Headers
}

func (d *DocumentsInit200ResponseResumedUploadPresignedPresigned) GetMethod() DocumentsInit200ResponseResumedUploadPresignedPresignedMethod {
	if d == nil {
		return ""
	}
	return d.Method
}

func (d *DocumentsInit200ResponseResumedUploadPresignedPresigned) GetExpiresAt() float64 {
	if d == nil {
		return 0
	}
	return d.ExpiresAt
}

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

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

// SetURL sets the URL field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedUploadPresignedPresigned) SetURL(url string) {
	d.URL = url
	d.require(documentsInit200ResponseResumedUploadPresignedPresignedFieldURL)
}

// SetHeaders sets the Headers field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedUploadPresignedPresigned) SetHeaders(headers map[string]string) {
	d.Headers = headers
	d.require(documentsInit200ResponseResumedUploadPresignedPresignedFieldHeaders)
}

// SetMethod sets the Method field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedUploadPresignedPresigned) SetMethod(method DocumentsInit200ResponseResumedUploadPresignedPresignedMethod) {
	d.Method = method
	d.require(documentsInit200ResponseResumedUploadPresignedPresignedFieldMethod)
}

// SetExpiresAt sets the ExpiresAt field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedUploadPresignedPresigned) SetExpiresAt(expiresAt float64) {
	d.ExpiresAt = expiresAt
	d.require(documentsInit200ResponseResumedUploadPresignedPresignedFieldExpiresAt)
}

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

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

func (d *DocumentsInit200ResponseResumedUploadPresignedPresigned) String() string {
	if d == nil {
		return "<nil>"
	}
	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)
}

type DocumentsInit200ResponseResumedUploadPresignedPresignedMethod string

const (
	DocumentsInit200ResponseResumedUploadPresignedPresignedMethodPut DocumentsInit200ResponseResumedUploadPresignedPresignedMethod = "PUT"
)

func NewDocumentsInit200ResponseResumedUploadPresignedPresignedMethodFromString(s string) (DocumentsInit200ResponseResumedUploadPresignedPresignedMethod, error) {
	switch s {
	case "PUT":
		return DocumentsInit200ResponseResumedUploadPresignedPresignedMethodPut, nil
	}
	var t DocumentsInit200ResponseResumedUploadPresignedPresignedMethod
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsInit200ResponseResumedUploadPresignedPresignedMethod) Ptr() *DocumentsInit200ResponseResumedUploadPresignedPresignedMethod {
	return &d
}

var (
	documentsInit200ResponseResumedUploadProxyFieldURL = big.NewInt(1 << 0)
	documentsInit200ResponseResumedUploadProxyFieldKey = big.NewInt(1 << 1)
)

type DocumentsInit200ResponseResumedUploadProxy struct {
	URL string `json:"url" url:"url"`
	Key string `json:"key" url:"key"`

	// 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 *DocumentsInit200ResponseResumedUploadProxy) GetURL() string {
	if d == nil {
		return ""
	}
	return d.URL
}

func (d *DocumentsInit200ResponseResumedUploadProxy) GetKey() string {
	if d == nil {
		return ""
	}
	return d.Key
}

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

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

// SetURL sets the URL field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedUploadProxy) SetURL(url string) {
	d.URL = url
	d.require(documentsInit200ResponseResumedUploadProxyFieldURL)
}

// SetKey sets the Key field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsInit200ResponseResumedUploadProxy) SetKey(key string) {
	d.Key = key
	d.require(documentsInit200ResponseResumedUploadProxyFieldKey)
}

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

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

func (d *DocumentsInit200ResponseResumedUploadProxy) String() string {
	if d == nil {
		return "<nil>"
	}
	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 (
	documentsList200ResponseFieldDocuments  = big.NewInt(1 << 0)
	documentsList200ResponseFieldNextCursor = big.NewInt(1 << 1)
)

type DocumentsList200Response struct {
	Documents  []*DocumentsList200ResponseDocumentsItem `json:"documents" url:"documents"`
	NextCursor *string                                  `json:"nextCursor,omitempty" url:"nextCursor,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 (d *DocumentsList200Response) GetDocuments() []*DocumentsList200ResponseDocumentsItem {
	if d == nil {
		return nil
	}
	return d.Documents
}

func (d *DocumentsList200Response) GetNextCursor() *string {
	if d == nil {
		return nil
	}
	return d.NextCursor
}

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

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

// SetDocuments sets the Documents field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsList200Response) SetDocuments(documents []*DocumentsList200ResponseDocumentsItem) {
	d.Documents = documents
	d.require(documentsList200ResponseFieldDocuments)
}

// SetNextCursor sets the NextCursor field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsList200Response) SetNextCursor(nextCursor *string) {
	d.NextCursor = nextCursor
	d.require(documentsList200ResponseFieldNextCursor)
}

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

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

func (d *DocumentsList200Response) String() string {
	if d == nil {
		return "<nil>"
	}
	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 (
	documentsList200ResponseDocumentsItemFieldID               = big.NewInt(1 << 0)
	documentsList200ResponseDocumentsItemFieldTenantID         = big.NewInt(1 << 1)
	documentsList200ResponseDocumentsItemFieldState            = big.NewInt(1 << 2)
	documentsList200ResponseDocumentsItemFieldBaseSha          = big.NewInt(1 << 3)
	documentsList200ResponseDocumentsItemFieldStorageSizeBytes = big.NewInt(1 << 4)
	documentsList200ResponseDocumentsItemFieldMetadata         = big.NewInt(1 << 5)
	documentsList200ResponseDocumentsItemFieldIdempotencyKey   = big.NewInt(1 << 6)
	documentsList200ResponseDocumentsItemFieldFailureReason    = big.NewInt(1 << 7)
	documentsList200ResponseDocumentsItemFieldThumbnailState   = big.NewInt(1 << 8)
	documentsList200ResponseDocumentsItemFieldThumbnailURL     = big.NewInt(1 << 9)
	documentsList200ResponseDocumentsItemFieldCreatedAt        = big.NewInt(1 << 10)
	documentsList200ResponseDocumentsItemFieldUpdatedAt        = big.NewInt(1 << 11)
	documentsList200ResponseDocumentsItemFieldCreatedBy        = big.NewInt(1 << 12)
)

type DocumentsList200ResponseDocumentsItem struct {
	ID               string                                               `json:"id" url:"id"`
	TenantID         string                                               `json:"tenantId" url:"tenantId"`
	State            DocumentsList200ResponseDocumentsItemState           `json:"state" url:"state"`
	BaseSha          *string                                              `json:"baseSha,omitempty" url:"baseSha,omitempty"`
	StorageSizeBytes *float64                                             `json:"storageSizeBytes,omitempty" url:"storageSizeBytes,omitempty"`
	Metadata         map[string]any                                       `json:"metadata,omitempty" url:"metadata,omitempty"`
	IdempotencyKey   *string                                              `json:"idempotencyKey,omitempty" url:"idempotencyKey,omitempty"`
	FailureReason    *string                                              `json:"failureReason,omitempty" url:"failureReason,omitempty"`
	ThumbnailState   *DocumentsList200ResponseDocumentsItemThumbnailState `json:"thumbnailState,omitempty" url:"thumbnailState,omitempty"`
	ThumbnailURL     *string                                              `json:"thumbnailUrl,omitempty" url:"thumbnailUrl,omitempty"`
	CreatedAt        float64                                              `json:"createdAt" url:"createdAt"`
	UpdatedAt        float64                                              `json:"updatedAt" url:"updatedAt"`
	CreatedBy        *string                                              `json:"createdBy,omitempty" url:"createdBy,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 (d *DocumentsList200ResponseDocumentsItem) GetID() string {
	if d == nil {
		return ""
	}
	return d.ID
}

func (d *DocumentsList200ResponseDocumentsItem) GetTenantID() string {
	if d == nil {
		return ""
	}
	return d.TenantID
}

func (d *DocumentsList200ResponseDocumentsItem) GetState() DocumentsList200ResponseDocumentsItemState {
	if d == nil {
		return ""
	}
	return d.State
}

func (d *DocumentsList200ResponseDocumentsItem) GetBaseSha() *string {
	if d == nil {
		return nil
	}
	return d.BaseSha
}

func (d *DocumentsList200ResponseDocumentsItem) GetStorageSizeBytes() *float64 {
	if d == nil {
		return nil
	}
	return d.StorageSizeBytes
}

func (d *DocumentsList200ResponseDocumentsItem) GetMetadata() map[string]any {
	if d == nil {
		return nil
	}
	return d.Metadata
}

func (d *DocumentsList200ResponseDocumentsItem) GetIdempotencyKey() *string {
	if d == nil {
		return nil
	}
	return d.IdempotencyKey
}

func (d *DocumentsList200ResponseDocumentsItem) GetFailureReason() *string {
	if d == nil {
		return nil
	}
	return d.FailureReason
}

func (d *DocumentsList200ResponseDocumentsItem) GetThumbnailState() *DocumentsList200ResponseDocumentsItemThumbnailState {
	if d == nil {
		return nil
	}
	return d.ThumbnailState
}

func (d *DocumentsList200ResponseDocumentsItem) GetThumbnailURL() *string {
	if d == nil {
		return nil
	}
	return d.ThumbnailURL
}

func (d *DocumentsList200ResponseDocumentsItem) GetCreatedAt() float64 {
	if d == nil {
		return 0
	}
	return d.CreatedAt
}

func (d *DocumentsList200ResponseDocumentsItem) GetUpdatedAt() float64 {
	if d == nil {
		return 0
	}
	return d.UpdatedAt
}

func (d *DocumentsList200ResponseDocumentsItem) GetCreatedBy() *string {
	if d == nil {
		return nil
	}
	return d.CreatedBy
}

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

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

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsList200ResponseDocumentsItem) SetTenantID(tenantID string) {
	d.TenantID = tenantID
	d.require(documentsList200ResponseDocumentsItemFieldTenantID)
}

// SetState sets the State field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsList200ResponseDocumentsItem) SetState(state DocumentsList200ResponseDocumentsItemState) {
	d.State = state
	d.require(documentsList200ResponseDocumentsItemFieldState)
}

// SetBaseSha sets the BaseSha field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsList200ResponseDocumentsItem) SetBaseSha(baseSha *string) {
	d.BaseSha = baseSha
	d.require(documentsList200ResponseDocumentsItemFieldBaseSha)
}

// SetStorageSizeBytes sets the StorageSizeBytes field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsList200ResponseDocumentsItem) SetStorageSizeBytes(storageSizeBytes *float64) {
	d.StorageSizeBytes = storageSizeBytes
	d.require(documentsList200ResponseDocumentsItemFieldStorageSizeBytes)
}

// SetMetadata sets the Metadata field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsList200ResponseDocumentsItem) SetMetadata(metadata map[string]any) {
	d.Metadata = metadata
	d.require(documentsList200ResponseDocumentsItemFieldMetadata)
}

// SetIdempotencyKey sets the IdempotencyKey field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsList200ResponseDocumentsItem) SetIdempotencyKey(idempotencyKey *string) {
	d.IdempotencyKey = idempotencyKey
	d.require(documentsList200ResponseDocumentsItemFieldIdempotencyKey)
}

// SetFailureReason sets the FailureReason field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsList200ResponseDocumentsItem) SetFailureReason(failureReason *string) {
	d.FailureReason = failureReason
	d.require(documentsList200ResponseDocumentsItemFieldFailureReason)
}

// SetThumbnailState sets the ThumbnailState field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsList200ResponseDocumentsItem) SetThumbnailState(thumbnailState *DocumentsList200ResponseDocumentsItemThumbnailState) {
	d.ThumbnailState = thumbnailState
	d.require(documentsList200ResponseDocumentsItemFieldThumbnailState)
}

// SetThumbnailURL sets the ThumbnailURL field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsList200ResponseDocumentsItem) SetThumbnailURL(thumbnailURL *string) {
	d.ThumbnailURL = thumbnailURL
	d.require(documentsList200ResponseDocumentsItemFieldThumbnailURL)
}

// 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 (d *DocumentsList200ResponseDocumentsItem) SetCreatedAt(createdAt float64) {
	d.CreatedAt = createdAt
	d.require(documentsList200ResponseDocumentsItemFieldCreatedAt)
}

// 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 (d *DocumentsList200ResponseDocumentsItem) SetUpdatedAt(updatedAt float64) {
	d.UpdatedAt = updatedAt
	d.require(documentsList200ResponseDocumentsItemFieldUpdatedAt)
}

// SetCreatedBy sets the CreatedBy field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsList200ResponseDocumentsItem) SetCreatedBy(createdBy *string) {
	d.CreatedBy = createdBy
	d.require(documentsList200ResponseDocumentsItemFieldCreatedBy)
}

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

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

func (d *DocumentsList200ResponseDocumentsItem) String() string {
	if d == nil {
		return "<nil>"
	}
	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)
}

type DocumentsList200ResponseDocumentsItemState string

const (
	DocumentsList200ResponseDocumentsItemStatePending  DocumentsList200ResponseDocumentsItemState = "pending"
	DocumentsList200ResponseDocumentsItemStateReady    DocumentsList200ResponseDocumentsItemState = "ready"
	DocumentsList200ResponseDocumentsItemStateFailed   DocumentsList200ResponseDocumentsItemState = "failed"
	DocumentsList200ResponseDocumentsItemStateDeleting DocumentsList200ResponseDocumentsItemState = "deleting"
)

func NewDocumentsList200ResponseDocumentsItemStateFromString(s string) (DocumentsList200ResponseDocumentsItemState, error) {
	switch s {
	case "pending":
		return DocumentsList200ResponseDocumentsItemStatePending, nil
	case "ready":
		return DocumentsList200ResponseDocumentsItemStateReady, nil
	case "failed":
		return DocumentsList200ResponseDocumentsItemStateFailed, nil
	case "deleting":
		return DocumentsList200ResponseDocumentsItemStateDeleting, nil
	}
	var t DocumentsList200ResponseDocumentsItemState
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsList200ResponseDocumentsItemState) Ptr() *DocumentsList200ResponseDocumentsItemState {
	return &d
}

type DocumentsList200ResponseDocumentsItemThumbnailState string

const (
	DocumentsList200ResponseDocumentsItemThumbnailStatePending DocumentsList200ResponseDocumentsItemThumbnailState = "pending"
	DocumentsList200ResponseDocumentsItemThumbnailStateReady   DocumentsList200ResponseDocumentsItemThumbnailState = "ready"
	DocumentsList200ResponseDocumentsItemThumbnailStateLocked  DocumentsList200ResponseDocumentsItemThumbnailState = "locked"
	DocumentsList200ResponseDocumentsItemThumbnailStateFailed  DocumentsList200ResponseDocumentsItemThumbnailState = "failed"
)

func NewDocumentsList200ResponseDocumentsItemThumbnailStateFromString(s string) (DocumentsList200ResponseDocumentsItemThumbnailState, error) {
	switch s {
	case "pending":
		return DocumentsList200ResponseDocumentsItemThumbnailStatePending, nil
	case "ready":
		return DocumentsList200ResponseDocumentsItemThumbnailStateReady, nil
	case "locked":
		return DocumentsList200ResponseDocumentsItemThumbnailStateLocked, nil
	case "failed":
		return DocumentsList200ResponseDocumentsItemThumbnailStateFailed, nil
	}
	var t DocumentsList200ResponseDocumentsItemThumbnailState
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsList200ResponseDocumentsItemThumbnailState) Ptr() *DocumentsList200ResponseDocumentsItemThumbnailState {
	return &d
}

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

type DocumentsUploadProxy200Response struct {
	Sha256 string `json:"sha256" url:"sha256"`

	// 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 *DocumentsUploadProxy200Response) GetSha256() string {
	if d == nil {
		return ""
	}
	return d.Sha256
}

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

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

// SetSha256 sets the Sha256 field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsUploadProxy200Response) SetSha256(sha256 string) {
	d.Sha256 = sha256
	d.require(documentsUploadProxy200ResponseFieldSha256)
}

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

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

func (d *DocumentsUploadProxy200Response) String() string {
	if d == nil {
		return "<nil>"
	}
	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)
}

// always-create (default) creates a new document every time. reuse-existing returns a document that already holds the same content instead of storing it twice.
type DocumentsImportFromRequestDedupMode string

const (
	DocumentsImportFromRequestDedupModeAlwaysCreate  DocumentsImportFromRequestDedupMode = "always-create"
	DocumentsImportFromRequestDedupModeReuseExisting DocumentsImportFromRequestDedupMode = "reuse-existing"
)

func NewDocumentsImportFromRequestDedupModeFromString(s string) (DocumentsImportFromRequestDedupMode, error) {
	switch s {
	case "always-create":
		return DocumentsImportFromRequestDedupModeAlwaysCreate, nil
	case "reuse-existing":
		return DocumentsImportFromRequestDedupModeReuseExisting, nil
	}
	var t DocumentsImportFromRequestDedupMode
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsImportFromRequestDedupMode) Ptr() *DocumentsImportFromRequestDedupMode {
	return &d
}

// Integrity pins, enforced when present. When absent, the server-observed values become authoritative.
var (
	documentsImportFromRequestExpectedFieldSizeBytes = big.NewInt(1 << 0)
	documentsImportFromRequestExpectedFieldSha256    = big.NewInt(1 << 1)
)

type DocumentsImportFromRequestExpected struct {
	// Checked against the source's declared Content-Length before the transfer.
	SizeBytes *int `json:"sizeBytes,omitempty" url:"sizeBytes,omitempty"`
	// Checked against the server-observed digest after the transfer. Required when dedupMode is reuse-existing.
	Sha256 *string `json:"sha256,omitempty" url:"sha256,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 (d *DocumentsImportFromRequestExpected) GetSizeBytes() *int {
	if d == nil {
		return nil
	}
	return d.SizeBytes
}

func (d *DocumentsImportFromRequestExpected) GetSha256() *string {
	if d == nil {
		return nil
	}
	return d.Sha256
}

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

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

// SetSizeBytes sets the SizeBytes field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFromRequestExpected) SetSizeBytes(sizeBytes *int) {
	d.SizeBytes = sizeBytes
	d.require(documentsImportFromRequestExpectedFieldSizeBytes)
}

// SetSha256 sets the Sha256 field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFromRequestExpected) SetSha256(sha256 *string) {
	d.Sha256 = sha256
	d.require(documentsImportFromRequestExpectedFieldSha256)
}

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

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

func (d *DocumentsImportFromRequestExpected) String() string {
	if d == nil {
		return "<nil>"
	}
	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)
}

// sync (default) holds the response open for the whole transfer. async answers 202 with the document pending and transfers in the background; it requires a connection source, and filesystem connections additionally require expected.sha256.
type DocumentsImportFromRequestMode string

const (
	DocumentsImportFromRequestModeSync  DocumentsImportFromRequestMode = "sync"
	DocumentsImportFromRequestModeAsync DocumentsImportFromRequestMode = "async"
)

func NewDocumentsImportFromRequestModeFromString(s string) (DocumentsImportFromRequestMode, error) {
	switch s {
	case "sync":
		return DocumentsImportFromRequestModeSync, nil
	case "async":
		return DocumentsImportFromRequestModeAsync, nil
	}
	var t DocumentsImportFromRequestMode
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsImportFromRequestMode) Ptr() *DocumentsImportFromRequestMode {
	return &d
}

// Where CloudPDF pulls the bytes from. The two shapes differ in who supplies the authority to read, not in which storage vendor holds the file.
type DocumentsImportFromRequestSource struct {
	Kind string
	// The caller supplies the authority: a presigned S3/GCS/Azure/R2/MinIO GET, or any HTTPS endpoint the deployment import policy allows. The URL is a capability — treat it as a secret. CloudPDF never echoes its query string back in errors, logs, or stored failure reasons.
	URL *DocumentsImportFromRequestSourceURL
	// The operator pre-registered the authority: the request names a connection and a key inside it. Which provider backs the connection (S3, GCS, Azure Blob, filesystem, ...) is deployment configuration, never wire surface.
	Connection *DocumentsImportFromRequestSourceConnection

	rawJSON json.RawMessage
}

func (d *DocumentsImportFromRequestSource) GetKind() string {
	if d == nil {
		return ""
	}
	return d.Kind
}

func (d *DocumentsImportFromRequestSource) GetURL() *DocumentsImportFromRequestSourceURL {
	if d == nil {
		return nil
	}
	return d.URL
}

func (d *DocumentsImportFromRequestSource) GetConnection() *DocumentsImportFromRequestSourceConnection {
	if d == nil {
		return nil
	}
	return d.Connection
}

func (d *DocumentsImportFromRequestSource) UnmarshalJSON(data []byte) error {
	var unmarshaler struct {
		Kind string `json:"kind"`
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	d.Kind = unmarshaler.Kind
	if unmarshaler.Kind == "" {
		return fmt.Errorf("%T did not include discriminant kind", d)
	}
	switch unmarshaler.Kind {
	case "url":
		value := new(DocumentsImportFromRequestSourceURL)
		if err := json.Unmarshal(data, &value); err != nil {
			return err
		}
		d.URL = value
	case "connection":
		value := new(DocumentsImportFromRequestSourceConnection)
		if err := json.Unmarshal(data, &value); err != nil {
			return err
		}
		d.Connection = value
	}
	d.rawJSON = json.RawMessage(data)
	return nil
}

func (d DocumentsImportFromRequestSource) MarshalJSON() ([]byte, error) {
	if err := d.validate(); err != nil {
		return nil, err
	}
	if d.URL != nil {
		return internal.MarshalJSONWithExtraProperty(d.URL, "kind", "url")
	}
	if d.Connection != nil {
		return internal.MarshalJSONWithExtraProperty(d.Connection, "kind", "connection")
	}
	if len(d.rawJSON) > 0 {
		return d.rawJSON, nil
	}
	return nil, fmt.Errorf("type %T does not define a non-empty union type", d)
}

type DocumentsImportFromRequestSourceVisitor interface {
	VisitURL(*DocumentsImportFromRequestSourceURL) error
	VisitConnection(*DocumentsImportFromRequestSourceConnection) error
}

func (d *DocumentsImportFromRequestSource) Accept(visitor DocumentsImportFromRequestSourceVisitor) error {
	if d.URL != nil {
		return visitor.VisitURL(d.URL)
	}
	if d.Connection != nil {
		return visitor.VisitConnection(d.Connection)
	}
	return fmt.Errorf("type %T does not define a non-empty union type", d)
}

func (d *DocumentsImportFromRequestSource) validate() error {
	if d == nil {
		return fmt.Errorf("type %T is nil", d)
	}
	var fields []string
	if d.URL != nil {
		fields = append(fields, "url")
	}
	if d.Connection != nil {
		fields = append(fields, "connection")
	}
	if len(fields) == 0 {
		if d.Kind != "" {
			if len(d.rawJSON) > 0 {
				return nil
			}
			return fmt.Errorf("type %T defines a discriminant set to %q but the field is not set", d, d.Kind)
		}
		return fmt.Errorf("type %T is empty", d)
	}
	if len(fields) > 1 {
		return fmt.Errorf("type %T defines values for %s, but only one value is allowed", d, fields)
	}
	if d.Kind != "" {
		field := fields[0]
		if d.Kind != field {
			return fmt.Errorf(
				"type %T defines a discriminant set to %q, but it does not match the %T field; either remove or update the discriminant to match",
				d,
				d.Kind,
				d,
			)
		}
	}
	return nil
}

// The operator pre-registered the authority: the request names a connection and a key inside it. Which provider backs the connection (S3, GCS, Azure Blob, filesystem, ...) is deployment configuration, never wire surface.
var (
	documentsImportFromRequestSourceConnectionFieldConnectionID = big.NewInt(1 << 0)
	documentsImportFromRequestSourceConnectionFieldKey          = big.NewInt(1 << 1)
	documentsImportFromRequestSourceConnectionFieldRevision     = big.NewInt(1 << 2)
)

type DocumentsImportFromRequestSourceConnection struct {
	// The operator-registered storage connection to read from.
	ConnectionID string `json:"connectionId" url:"connectionId"`
	// The object key to read, inside the connection's configured scope. At most 1024 UTF-8 bytes.
	Key string `json:"key" url:"key"`
	// Pins a specific version of the object. Provider-interpreted (S3 VersionId, GCS generation, Azure version id); providers without versioning reject it.
	Revision *string `json:"revision,omitempty" url:"revision,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 (d *DocumentsImportFromRequestSourceConnection) GetConnectionID() string {
	if d == nil {
		return ""
	}
	return d.ConnectionID
}

func (d *DocumentsImportFromRequestSourceConnection) GetKey() string {
	if d == nil {
		return ""
	}
	return d.Key
}

func (d *DocumentsImportFromRequestSourceConnection) GetRevision() *string {
	if d == nil {
		return nil
	}
	return d.Revision
}

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

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

// SetConnectionID sets the ConnectionID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFromRequestSourceConnection) SetConnectionID(connectionID string) {
	d.ConnectionID = connectionID
	d.require(documentsImportFromRequestSourceConnectionFieldConnectionID)
}

// SetKey sets the Key field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFromRequestSourceConnection) SetKey(key string) {
	d.Key = key
	d.require(documentsImportFromRequestSourceConnectionFieldKey)
}

// SetRevision sets the Revision field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFromRequestSourceConnection) SetRevision(revision *string) {
	d.Revision = revision
	d.require(documentsImportFromRequestSourceConnectionFieldRevision)
}

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

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

func (d *DocumentsImportFromRequestSourceConnection) String() string {
	if d == nil {
		return "<nil>"
	}
	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)
}

// The caller supplies the authority: a presigned S3/GCS/Azure/R2/MinIO GET, or any HTTPS endpoint the deployment import policy allows. The URL is a capability — treat it as a secret. CloudPDF never echoes its query string back in errors, logs, or stored failure reasons.
var (
	documentsImportFromRequestSourceURLFieldURL = big.NewInt(1 << 0)
)

type DocumentsImportFromRequestSourceURL struct {
	// The URL to fetch. Must be allowed by the deployment import policy (scheme, network range, size) and must declare a length.
	URL string `json:"url" url:"url"`

	// 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 *DocumentsImportFromRequestSourceURL) GetURL() string {
	if d == nil {
		return ""
	}
	return d.URL
}

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

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

// SetURL sets the URL field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DocumentsImportFromRequestSourceURL) SetURL(url string) {
	d.URL = url
	d.require(documentsImportFromRequestSourceURLFieldURL)
}

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

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

func (d *DocumentsImportFromRequestSourceURL) String() string {
	if d == nil {
		return "<nil>"
	}
	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)
}

// always-create (default) creates a new document every time. reuse-existing returns a document that already holds the same content instead of storing it twice.
type DocumentsInitRequestDedupMode string

const (
	DocumentsInitRequestDedupModeAlwaysCreate  DocumentsInitRequestDedupMode = "always-create"
	DocumentsInitRequestDedupModeReuseExisting DocumentsInitRequestDedupMode = "reuse-existing"
)

func NewDocumentsInitRequestDedupModeFromString(s string) (DocumentsInitRequestDedupMode, error) {
	switch s {
	case "always-create":
		return DocumentsInitRequestDedupModeAlwaysCreate, nil
	case "reuse-existing":
		return DocumentsInitRequestDedupModeReuseExisting, nil
	}
	var t DocumentsInitRequestDedupMode
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsInitRequestDedupMode) Ptr() *DocumentsInitRequestDedupMode {
	return &d
}

type DocumentsInitRequestUploadPreference string

const (
	DocumentsInitRequestUploadPreferenceAuto      DocumentsInitRequestUploadPreference = "auto"
	DocumentsInitRequestUploadPreferencePresigned DocumentsInitRequestUploadPreference = "presigned"
	DocumentsInitRequestUploadPreferenceProxy     DocumentsInitRequestUploadPreference = "proxy"
)

func NewDocumentsInitRequestUploadPreferenceFromString(s string) (DocumentsInitRequestUploadPreference, error) {
	switch s {
	case "auto":
		return DocumentsInitRequestUploadPreferenceAuto, nil
	case "presigned":
		return DocumentsInitRequestUploadPreferencePresigned, nil
	case "proxy":
		return DocumentsInitRequestUploadPreferenceProxy, nil
	}
	var t DocumentsInitRequestUploadPreference
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (d DocumentsInitRequestUploadPreference) Ptr() *DocumentsInitRequestUploadPreference {
	return &d
}

type ListDocumentsRequestState string

const (
	ListDocumentsRequestStatePending  ListDocumentsRequestState = "pending"
	ListDocumentsRequestStateReady    ListDocumentsRequestState = "ready"
	ListDocumentsRequestStateFailed   ListDocumentsRequestState = "failed"
	ListDocumentsRequestStateDeleting ListDocumentsRequestState = "deleting"
)

func NewListDocumentsRequestStateFromString(s string) (ListDocumentsRequestState, error) {
	switch s {
	case "pending":
		return ListDocumentsRequestStatePending, nil
	case "ready":
		return ListDocumentsRequestStateReady, nil
	case "failed":
		return ListDocumentsRequestStateFailed, nil
	case "deleting":
		return ListDocumentsRequestStateDeleting, nil
	}
	var t ListDocumentsRequestState
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

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

var (
	uploadProxyDocumentsRequestFieldTenantID = big.NewInt(1 << 0)
	uploadProxyDocumentsRequestFieldID       = big.NewInt(1 << 1)
)

type UploadProxyDocumentsRequest struct {
	TenantID string    `json:"-" url:"-"`
	ID       string    `json:"-" url:"-"`
	File     io.Reader `json:"-" url:"-"`

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

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

// SetTenantID sets the TenantID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (u *UploadProxyDocumentsRequest) SetTenantID(tenantID string) {
	u.TenantID = tenantID
	u.require(uploadProxyDocumentsRequestFieldTenantID)
}

// 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 (u *UploadProxyDocumentsRequest) SetID(id string) {
	u.ID = id
	u.require(uploadProxyDocumentsRequestFieldID)
}

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

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