From 7a532e9373defdb210b17bd16ffc35585afe9aa0 Mon Sep 17 00:00:00 2001 From: cloudpdf-sdk-bot Date: Thu, 27 Aug 2026 19:44:53 +0000 Subject: [PATCH] chore: generate CloudPDF Go SDK 3.0.0-next.9 --- .fern/metadata.json | 6 +- cloudpdf-generation.json | 8 +- core/request_option.go | 4 +- doc/pages.go | 184 + doc/pages/client.go | 96 + doc/pages/doc_pages_test/doc_pages_test.go | 61 + doc/pages/raw_client.go | 164 + doc/pages_test.go | 369 + reference.md | 258 + types.go | 4030 +++++++++- types_test.go | 8258 ++++++++++++++++++-- wiremock/wiremock-mappings.json | 119 +- 12 files changed, 12552 insertions(+), 1005 deletions(-) diff --git a/.fern/metadata.json b/.fern/metadata.json index 83b0709..ebdd5b4 100644 --- a/.fern/metadata.json +++ b/.fern/metadata.json @@ -9,10 +9,10 @@ "version": "1.21" } }, - "originGitCommit": "20cebe429411ef5019c9e31fc7841d72b7fb98a8", + "originGitCommit": "e5cd0731cb3a1f2ed5821f8d60191bd58934c3dd", "originGitCommitIsDirty": false, "invokedBy": "ci", - "requestedVersion": "3.0.0-next.8", + "requestedVersion": "3.0.0-next.9", "ciProvider": "github", - "sdkVersion": "v3.0.0-next.8" + "sdkVersion": "v3.0.0-next.9" } \ No newline at end of file diff --git a/cloudpdf-generation.json b/cloudpdf-generation.json index 61478bd..223c5eb 100644 --- a/cloudpdf-generation.json +++ b/cloudpdf-generation.json @@ -1,12 +1,12 @@ { "language": "go", - "canonicalVersion": "3.0.0-next.8", - "sdkVersion": "3.0.0-next.8", + "canonicalVersion": "3.0.0-next.9", + "sdkVersion": "3.0.0-next.9", "source": { "repository": "embedpdf/embed-pdf-viewer", "openapi": "cloudpdf/contract/openapi.json", - "openapiSha256": "e997d51317662fe0666e6582916ded9b17a8bcd225c178548e1ff226e4d01c6d", - "gitCommit": "20cebe429411ef5019c9e31fc7841d72b7fb98a8", + "openapiSha256": "4ee27900dbb0b13408ce00a0e80d606444ab81e9d5a76186fa984c8c8dfe09fe", + "gitCommit": "e5cd0731cb3a1f2ed5821f8d60191bd58934c3dd", "gitCommitIsDirty": false }, "fern": { diff --git a/core/request_option.go b/core/request_option.go index b1c68ab..290b6d1 100644 --- a/core/request_option.go +++ b/core/request_option.go @@ -65,8 +65,8 @@ func (r *RequestOptions) cloneHeader() http.Header { headers := r.HTTPHeader.Clone() headers.Set("X-Fern-Language", "Go") headers.Set("X-Fern-SDK-Name", "github.com/embedpdf/cloudpdf-sdk-go/v3") - headers.Set("X-Fern-SDK-Version", "v3.0.0-next.8") - headers.Set("User-Agent", "github.com/embedpdf/cloudpdf-sdk-go/v3/3.0.0-next.8") + headers.Set("X-Fern-SDK-Version", "v3.0.0-next.9") + headers.Set("User-Agent", "github.com/embedpdf/cloudpdf-sdk-go/v3/3.0.0-next.9") return headers } diff --git a/doc/pages.go b/doc/pages.go index 2adf5ba..0215c81 100644 --- a/doc/pages.go +++ b/doc/pages.go @@ -5,6 +5,8 @@ package doc import ( json "encoding/json" v3 "github.com/embedpdf/cloudpdf-sdk-go/v3" + internal "github.com/embedpdf/cloudpdf-sdk-go/v3/internal" + io "io" big "math/big" ) @@ -66,6 +68,64 @@ func (d *DeletePagesRequest) MarshalJSON() ([]byte, error) { return json.Marshal(d.Body) } +var ( + extractPagesRequestFieldDocumentPassword = big.NewInt(1 << 0) + extractPagesRequestFieldDocID = big.NewInt(1 << 1) + extractPagesRequestFieldLayerName = big.NewInt(1 << 2) +) + +type ExtractPagesRequest struct { + // Base64-encoded password for an encrypted document. Valid only with the API token (403 anywhere else). An encrypted document answers 422 DocPasswordRequired when the header is absent. Viewer doc JWTs use the SDK password-session flow instead. + DocumentPassword *string `json:"-" url:"-"` + DocID string `json:"-" url:"-"` + LayerName string `json:"-" url:"-"` + Body v3.DocPagesExtractRequest `json:"-" url:"-"` + + // Private bitmask of fields set to an explicit value and therefore not to be omitted + explicitFields *big.Int `json:"-" url:"-"` +} + +func (e *ExtractPagesRequest) require(field *big.Int) { + if e.explicitFields == nil { + e.explicitFields = big.NewInt(0) + } + e.explicitFields.Or(e.explicitFields, field) +} + +// SetDocumentPassword sets the DocumentPassword field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (e *ExtractPagesRequest) SetDocumentPassword(documentPassword *string) { + e.DocumentPassword = documentPassword + e.require(extractPagesRequestFieldDocumentPassword) +} + +// 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 (e *ExtractPagesRequest) SetDocID(docID string) { + e.DocID = docID + e.require(extractPagesRequestFieldDocID) +} + +// SetLayerName sets the LayerName field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (e *ExtractPagesRequest) SetLayerName(layerName string) { + e.LayerName = layerName + e.require(extractPagesRequestFieldLayerName) +} + +func (e *ExtractPagesRequest) UnmarshalJSON(data []byte) error { + var body v3.DocPagesExtractRequest + if err := json.Unmarshal(data, &body); err != nil { + return err + } + e.Body = body + return nil +} + +func (e *ExtractPagesRequest) MarshalJSON() ([]byte, error) { + return json.Marshal(e.Body) +} + var ( flattenPagesRequestFieldDocumentPassword = big.NewInt(1 << 0) flattenPagesRequestFieldDocID = big.NewInt(1 << 1) @@ -124,6 +184,130 @@ func (f *FlattenPagesRequest) MarshalJSON() ([]byte, error) { return json.Marshal(f.Body) } +var ( + insertPagesRequestFieldDocumentPassword = big.NewInt(1 << 0) + insertPagesRequestFieldDocID = big.NewInt(1 << 1) + insertPagesRequestFieldLayerName = big.NewInt(1 << 2) +) + +type InsertPagesRequest struct { + // Base64-encoded password for an encrypted document. Valid only with the API token (403 anywhere else). An encrypted document answers 422 DocPasswordRequired when the header is absent. Viewer doc JWTs use the SDK password-session flow instead. + DocumentPassword *string `json:"-" url:"-"` + DocID string `json:"-" url:"-"` + LayerName 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 (i *InsertPagesRequest) require(field *big.Int) { + if i.explicitFields == nil { + i.explicitFields = big.NewInt(0) + } + i.explicitFields.Or(i.explicitFields, field) +} + +// SetDocumentPassword sets the DocumentPassword field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (i *InsertPagesRequest) SetDocumentPassword(documentPassword *string) { + i.DocumentPassword = documentPassword + i.require(insertPagesRequestFieldDocumentPassword) +} + +// 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 (i *InsertPagesRequest) SetDocID(docID string) { + i.DocID = docID + i.require(insertPagesRequestFieldDocID) +} + +// SetLayerName sets the LayerName field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (i *InsertPagesRequest) SetLayerName(layerName string) { + i.LayerName = layerName + i.require(insertPagesRequestFieldLayerName) +} + +func (i *InsertPagesRequest) UnmarshalJSON(data []byte) error { + type unmarshaler InsertPagesRequest + var body unmarshaler + if err := json.Unmarshal(data, &body); err != nil { + return err + } + *i = InsertPagesRequest(body) + return nil +} + +func (i *InsertPagesRequest) MarshalJSON() ([]byte, error) { + type embed InsertPagesRequest + var marshaler = struct { + embed + }{ + embed: embed(*i), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, i.explicitFields) + return json.Marshal(explicitMarshaler) +} + +var ( + insertBlankPagesRequestFieldDocumentPassword = big.NewInt(1 << 0) + insertBlankPagesRequestFieldDocID = big.NewInt(1 << 1) + insertBlankPagesRequestFieldLayerName = big.NewInt(1 << 2) +) + +type InsertBlankPagesRequest struct { + // Base64-encoded password for an encrypted document. Valid only with the API token (403 anywhere else). An encrypted document answers 422 DocPasswordRequired when the header is absent. Viewer doc JWTs use the SDK password-session flow instead. + DocumentPassword *string `json:"-" url:"-"` + DocID string `json:"-" url:"-"` + LayerName string `json:"-" url:"-"` + Body v3.DocPagesInsertBlankRequest `json:"-" url:"-"` + + // Private bitmask of fields set to an explicit value and therefore not to be omitted + explicitFields *big.Int `json:"-" url:"-"` +} + +func (i *InsertBlankPagesRequest) require(field *big.Int) { + if i.explicitFields == nil { + i.explicitFields = big.NewInt(0) + } + i.explicitFields.Or(i.explicitFields, field) +} + +// SetDocumentPassword sets the DocumentPassword field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (i *InsertBlankPagesRequest) SetDocumentPassword(documentPassword *string) { + i.DocumentPassword = documentPassword + i.require(insertBlankPagesRequestFieldDocumentPassword) +} + +// 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 (i *InsertBlankPagesRequest) SetDocID(docID string) { + i.DocID = docID + i.require(insertBlankPagesRequestFieldDocID) +} + +// SetLayerName sets the LayerName field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (i *InsertBlankPagesRequest) SetLayerName(layerName string) { + i.LayerName = layerName + i.require(insertBlankPagesRequestFieldLayerName) +} + +func (i *InsertBlankPagesRequest) UnmarshalJSON(data []byte) error { + var body v3.DocPagesInsertBlankRequest + if err := json.Unmarshal(data, &body); err != nil { + return err + } + i.Body = body + return nil +} + +func (i *InsertBlankPagesRequest) MarshalJSON() ([]byte, error) { + return json.Marshal(i.Body) +} + var ( movePagesRequestFieldDocumentPassword = big.NewInt(1 << 0) movePagesRequestFieldDocID = big.NewInt(1 << 1) diff --git a/doc/pages/client.go b/doc/pages/client.go index 36d716f..b17c761 100644 --- a/doc/pages/client.go +++ b/doc/pages/client.go @@ -4,6 +4,7 @@ package pages import ( context "context" + io "io" cloudpdf "github.com/embedpdf/cloudpdf-sdk-go/v3" core "github.com/embedpdf/cloudpdf-sdk-go/v3/core" @@ -64,6 +65,39 @@ func (c *Client) Delete( return response.Body, nil } +// A read, not a mutation: the source document is untouched and no event is published. Body is `{"pageObjectNumbers": number[]}`; the response body is the new PDF. +// +// Example: +// +// request := &doc.ExtractPagesRequest{ +// DocID: "docId", +// LayerName: "layerName", +// Body: map[string]any{ +// "string": map[string]any{ +// "key": "value", +// }, +// }, +// } +// client.Doc.Pages.Extract( +// context.TODO(), +// request, +// ) +func (c *Client) Extract( + ctx context.Context, + request *doc.ExtractPagesRequest, + opts ...option.RequestOption, +) (io.Reader, error) { + response, err := c.WithRawResponse.Extract( + ctx, + request, + opts..., + ) + if err != nil { + return nil, err + } + return response.Body, nil +} + // Example: // // request := &doc.FlattenPagesRequest{ @@ -93,6 +127,68 @@ func (c *Client) Flatten( return response.Body, nil } +// Multipart mutation envelope: a `body` field holding `{"destIndex"?: number}` (omitted → append) plus a `resource:source` file part carrying the standalone PDF whose pages are copied in. The inserted copies get fresh page object numbers, returned in insertion order. +// +// Example: +// +// request := &doc.InsertPagesRequest{ +// DocID: "docId", +// LayerName: "layerName", +// File: strings.NewReader( +// "", +// ), +// } +// client.Doc.Pages.Insert( +// context.TODO(), +// request, +// ) +func (c *Client) Insert( + ctx context.Context, + request *doc.InsertPagesRequest, + opts ...option.RequestOption, +) (*cloudpdf.DocPagesInsert200Response, error) { + response, err := c.WithRawResponse.Insert( + ctx, + request, + opts..., + ) + if err != nil { + return nil, err + } + return response.Body, nil +} + +// Body is `{"size": {"width", "height"}, "count"?, "destIndex"?}` — size in PDF points, count in [1, 100], destIndex omitted → append. +// +// Example: +// +// request := &doc.InsertBlankPagesRequest{ +// DocID: "docId", +// LayerName: "layerName", +// Body: map[string]any{ +// "key": "value", +// }, +// } +// client.Doc.Pages.InsertBlank( +// context.TODO(), +// request, +// ) +func (c *Client) InsertBlank( + ctx context.Context, + request *doc.InsertBlankPagesRequest, + opts ...option.RequestOption, +) (*cloudpdf.DocPagesInsertBlank200Response, error) { + response, err := c.WithRawResponse.InsertBlank( + ctx, + request, + opts..., + ) + if err != nil { + return nil, err + } + return response.Body, nil +} + // Example: // // request := &doc.MovePagesRequest{ diff --git a/doc/pages/doc_pages_test/doc_pages_test.go b/doc/pages/doc_pages_test/doc_pages_test.go index 457ac9f..c62d2ca 100644 --- a/doc/pages/doc_pages_test/doc_pages_test.go +++ b/doc/pages/doc_pages_test/doc_pages_test.go @@ -8,6 +8,7 @@ import ( json "encoding/json" http "net/http" os "os" + strings "strings" testing "testing" client "github.com/embedpdf/cloudpdf-sdk-go/v3/client" @@ -137,6 +138,66 @@ func TestDocPagesFlattenWithWireMock( VerifyRequestCount(t, "TestDocPagesFlattenWithWireMock", "POST", "/v1/docs/docId/layers/layerName/pages/flatten", nil, 1) } +func TestDocPagesInsertWithWireMock( + t *testing.T, +) { + WireMockBaseURL := os.Getenv("WIREMOCK_URL") + if WireMockBaseURL == "" { + WireMockBaseURL = "http://localhost:8080" + } + client := client.NewClient( + option.WithBaseURL(WireMockBaseURL), + option.WithToken("test-token"), + ) + request := &doc.InsertPagesRequest{ + DocID: "docId", + LayerName: "layerName", + File: strings.NewReader( + "", + ), + } + _, invocationErr := client.Doc.Pages.Insert( + context.TODO(), + request, + option.WithHTTPHeader( + http.Header{"X-Test-Id": []string{"TestDocPagesInsertWithWireMock"}}, + ), + ) + + require.NoError(t, invocationErr, "Client method call should succeed") + VerifyRequestCount(t, "TestDocPagesInsertWithWireMock", "POST", "/v1/docs/docId/layers/layerName/pages/insert", nil, 1) +} + +func TestDocPagesInsertBlankWithWireMock( + t *testing.T, +) { + WireMockBaseURL := os.Getenv("WIREMOCK_URL") + if WireMockBaseURL == "" { + WireMockBaseURL = "http://localhost:8080" + } + client := client.NewClient( + option.WithBaseURL(WireMockBaseURL), + option.WithToken("test-token"), + ) + request := &doc.InsertBlankPagesRequest{ + DocID: "docId", + LayerName: "layerName", + Body: map[string]any{ + "key": "value", + }, + } + _, invocationErr := client.Doc.Pages.InsertBlank( + context.TODO(), + request, + option.WithHTTPHeader( + http.Header{"X-Test-Id": []string{"TestDocPagesInsertBlankWithWireMock"}}, + ), + ) + + require.NoError(t, invocationErr, "Client method call should succeed") + VerifyRequestCount(t, "TestDocPagesInsertBlankWithWireMock", "POST", "/v1/docs/docId/layers/layerName/pages/insert-blank", nil, 1) +} + func TestDocPagesMoveWithWireMock( t *testing.T, ) { diff --git a/doc/pages/raw_client.go b/doc/pages/raw_client.go index 43762a3..c3f9b0c 100644 --- a/doc/pages/raw_client.go +++ b/doc/pages/raw_client.go @@ -3,7 +3,9 @@ package pages import ( + bytes "bytes" context "context" + io "io" http "net/http" cloudpdf "github.com/embedpdf/cloudpdf-sdk-go/v3" @@ -84,6 +86,57 @@ func (r *RawClient) Delete( }, nil } +func (r *RawClient) Extract( + ctx context.Context, + request *doc.ExtractPagesRequest, + opts ...option.RequestOption, +) (*core.Response[io.Reader], error) { + options := core.NewRequestOptions(opts...) + baseURL := internal.ResolveBaseURL( + options.BaseURL, + r.baseURL, + "", + ) + endpointURL := internal.EncodeURL( + baseURL+"/v1/docs/%v/layers/%v/pages/extract", + request.DocID, + request.LayerName, + ) + headers := internal.MergeHeaders( + r.options.ToHeader(), + options.ToHeader(), + ) + if request.DocumentPassword != nil { + headers.Add("X-Document-Password", *request.DocumentPassword) + } + headers.Add("Content-Type", "application/json") + response := bytes.NewBuffer(nil) + raw, err := r.caller.Call( + ctx, + &internal.CallParams{ + URL: endpointURL, + Method: http.MethodPost, + Headers: headers, + MaxAttempts: options.MaxAttempts, + DisableRetries: options.DisableRetries, + BodyProperties: options.BodyProperties, + QueryParameters: options.QueryParameters, + Client: options.HTTPClient, + Request: request, + Response: response, + ErrorDecoder: internal.NewErrorDecoder(doc.ErrorCodes), + }, + ) + if err != nil { + return nil, err + } + return &core.Response[io.Reader]{ + StatusCode: raw.StatusCode, + Header: raw.Header, + Body: response, + }, nil +} + func (r *RawClient) Flatten( ctx context.Context, request *doc.FlattenPagesRequest, @@ -135,6 +188,117 @@ func (r *RawClient) Flatten( }, nil } +func (r *RawClient) Insert( + ctx context.Context, + request *doc.InsertPagesRequest, + opts ...option.RequestOption, +) (*core.Response[*cloudpdf.DocPagesInsert200Response], error) { + options := core.NewRequestOptions(opts...) + baseURL := internal.ResolveBaseURL( + options.BaseURL, + r.baseURL, + "", + ) + endpointURL := internal.EncodeURL( + baseURL+"/v1/docs/%v/layers/%v/pages/insert", + request.DocID, + request.LayerName, + ) + headers := internal.MergeHeaders( + r.options.ToHeader(), + options.ToHeader(), + ) + if request.DocumentPassword != nil { + headers.Add("X-Document-Password", *request.DocumentPassword) + } + + writer := internal.NewMultipartWriter() + if err := writer.WriteFile("file", request.File); err != nil { + return nil, err + } + if err := writer.Close(); err != nil { + return nil, err + } + headers.Set("Content-Type", writer.ContentType()) + + var response *cloudpdf.DocPagesInsert200Response + raw, err := r.caller.Call( + ctx, + &internal.CallParams{ + URL: endpointURL, + Method: http.MethodPost, + Headers: headers, + MaxAttempts: options.MaxAttempts, + DisableRetries: options.DisableRetries, + BodyProperties: options.BodyProperties, + QueryParameters: options.QueryParameters, + Client: options.HTTPClient, + Request: writer.Buffer(), + Response: &response, + ErrorDecoder: internal.NewErrorDecoder(doc.ErrorCodes), + }, + ) + if err != nil { + return nil, err + } + return &core.Response[*cloudpdf.DocPagesInsert200Response]{ + StatusCode: raw.StatusCode, + Header: raw.Header, + Body: response, + }, nil +} + +func (r *RawClient) InsertBlank( + ctx context.Context, + request *doc.InsertBlankPagesRequest, + opts ...option.RequestOption, +) (*core.Response[*cloudpdf.DocPagesInsertBlank200Response], error) { + options := core.NewRequestOptions(opts...) + baseURL := internal.ResolveBaseURL( + options.BaseURL, + r.baseURL, + "", + ) + endpointURL := internal.EncodeURL( + baseURL+"/v1/docs/%v/layers/%v/pages/insert-blank", + request.DocID, + request.LayerName, + ) + headers := internal.MergeHeaders( + r.options.ToHeader(), + options.ToHeader(), + ) + if request.DocumentPassword != nil { + headers.Add("X-Document-Password", *request.DocumentPassword) + } + headers.Add("Content-Type", "application/json") + var response *cloudpdf.DocPagesInsertBlank200Response + raw, err := r.caller.Call( + ctx, + &internal.CallParams{ + URL: endpointURL, + Method: http.MethodPost, + Headers: headers, + MaxAttempts: options.MaxAttempts, + DisableRetries: options.DisableRetries, + BodyProperties: options.BodyProperties, + QueryParameters: options.QueryParameters, + Client: options.HTTPClient, + Request: request, + Response: &response, + ErrorDecoder: internal.NewErrorDecoder(doc.ErrorCodes), + }, + ) + if err != nil { + return nil, err + } + return &core.Response[*cloudpdf.DocPagesInsertBlank200Response]{ + StatusCode: raw.StatusCode, + Header: raw.Header, + Body: response, + }, nil +} + func (r *RawClient) Move( ctx context.Context, request *doc.MovePagesRequest, diff --git a/doc/pages_test.go b/doc/pages_test.go index 40c20ed..293f68b 100644 --- a/doc/pages_test.go +++ b/doc/pages_test.go @@ -132,6 +132,129 @@ func TestSettersMarkExplicitDeletePagesRequest(t *testing.T) { } +func TestSettersExtractPagesRequest(t *testing.T) { + t.Run("SetDocumentPassword", func(t *testing.T) { + obj := &ExtractPagesRequest{} + var fernTestValueDocumentPassword *string + obj.SetDocumentPassword(fernTestValueDocumentPassword) + assert.Equal(t, fernTestValueDocumentPassword, obj.DocumentPassword) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetDocID", func(t *testing.T) { + obj := &ExtractPagesRequest{} + var fernTestValueDocID string + obj.SetDocID(fernTestValueDocID) + assert.Equal(t, fernTestValueDocID, obj.DocID) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetLayerName", func(t *testing.T) { + obj := &ExtractPagesRequest{} + var fernTestValueLayerName string + obj.SetLayerName(fernTestValueLayerName) + assert.Equal(t, fernTestValueLayerName, obj.LayerName) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestSettersMarkExplicitExtractPagesRequest(t *testing.T) { + t.Run("SetDocumentPassword_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &ExtractPagesRequest{} + var fernTestValueDocumentPassword *string + + // Act + obj.SetDocumentPassword(fernTestValueDocumentPassword) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetDocID_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &ExtractPagesRequest{} + var fernTestValueDocID string + + // Act + obj.SetDocID(fernTestValueDocID) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetLayerName_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &ExtractPagesRequest{} + var fernTestValueLayerName string + + // Act + obj.SetLayerName(fernTestValueLayerName) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + func TestSettersFlattenPagesRequest(t *testing.T) { t.Run("SetDocumentPassword", func(t *testing.T) { obj := &FlattenPagesRequest{} @@ -255,6 +378,252 @@ func TestSettersMarkExplicitFlattenPagesRequest(t *testing.T) { } +func TestSettersInsertPagesRequest(t *testing.T) { + t.Run("SetDocumentPassword", func(t *testing.T) { + obj := &InsertPagesRequest{} + var fernTestValueDocumentPassword *string + obj.SetDocumentPassword(fernTestValueDocumentPassword) + assert.Equal(t, fernTestValueDocumentPassword, obj.DocumentPassword) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetDocID", func(t *testing.T) { + obj := &InsertPagesRequest{} + var fernTestValueDocID string + obj.SetDocID(fernTestValueDocID) + assert.Equal(t, fernTestValueDocID, obj.DocID) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetLayerName", func(t *testing.T) { + obj := &InsertPagesRequest{} + var fernTestValueLayerName string + obj.SetLayerName(fernTestValueLayerName) + assert.Equal(t, fernTestValueLayerName, obj.LayerName) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestSettersMarkExplicitInsertPagesRequest(t *testing.T) { + t.Run("SetDocumentPassword_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &InsertPagesRequest{} + var fernTestValueDocumentPassword *string + + // Act + obj.SetDocumentPassword(fernTestValueDocumentPassword) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetDocID_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &InsertPagesRequest{} + var fernTestValueDocID string + + // Act + obj.SetDocID(fernTestValueDocID) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetLayerName_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &InsertPagesRequest{} + var fernTestValueLayerName string + + // Act + obj.SetLayerName(fernTestValueLayerName) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersInsertBlankPagesRequest(t *testing.T) { + t.Run("SetDocumentPassword", func(t *testing.T) { + obj := &InsertBlankPagesRequest{} + var fernTestValueDocumentPassword *string + obj.SetDocumentPassword(fernTestValueDocumentPassword) + assert.Equal(t, fernTestValueDocumentPassword, obj.DocumentPassword) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetDocID", func(t *testing.T) { + obj := &InsertBlankPagesRequest{} + var fernTestValueDocID string + obj.SetDocID(fernTestValueDocID) + assert.Equal(t, fernTestValueDocID, obj.DocID) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetLayerName", func(t *testing.T) { + obj := &InsertBlankPagesRequest{} + var fernTestValueLayerName string + obj.SetLayerName(fernTestValueLayerName) + assert.Equal(t, fernTestValueLayerName, obj.LayerName) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestSettersMarkExplicitInsertBlankPagesRequest(t *testing.T) { + t.Run("SetDocumentPassword_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &InsertBlankPagesRequest{} + var fernTestValueDocumentPassword *string + + // Act + obj.SetDocumentPassword(fernTestValueDocumentPassword) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetDocID_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &InsertBlankPagesRequest{} + var fernTestValueDocID string + + // Act + obj.SetDocID(fernTestValueDocID) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetLayerName_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &InsertBlankPagesRequest{} + var fernTestValueLayerName string + + // Act + obj.SetLayerName(fernTestValueLayerName) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + func TestSettersMovePagesRequest(t *testing.T) { t.Run("SetDocumentPassword", func(t *testing.T) { obj := &MovePagesRequest{} diff --git a/reference.md b/reference.md index 8ec0da7..02fd273 100644 --- a/reference.md +++ b/reference.md @@ -2899,6 +2899,96 @@ client.Doc.Pages.Delete( + + + + +
client.Doc.Pages.Extract(DocID, LayerName, request) -> string +
+
+ +#### 📝 Description + +
+
+ +
+
+ +A read, not a mutation: the source document is untouched and no event is published. Body is `{"pageObjectNumbers": number[]}`; the response body is the new PDF. +
+
+
+
+ +#### 🔌 Usage + +
+
+ +
+
+ +```go +request := &doc.ExtractPagesRequest{ + DocID: "docId", + LayerName: "layerName", + Body: map[string]any{ + "string": map[string]any{ + "key": "value", + }, + }, +} +client.Doc.Pages.Extract( + context.TODO(), + request, +) +``` +
+
+
+
+ +#### ⚙️ Parameters + +
+
+ +
+
+ +**docID:** `string` + +
+
+ +
+
+ +**layerName:** `string` + +
+
+ +
+
+ +**documentPassword:** `*string` — Base64-encoded password for an encrypted document. Valid only with the API token (403 anywhere else). An encrypted document answers 422 DocPasswordRequired when the header is absent. Viewer doc JWTs use the SDK password-session flow instead. + +
+
+ +
+
+ +**request:** `cloudpdf.DocPagesExtractRequest` + +
+
+
+
+ +
@@ -2973,6 +3063,174 @@ client.Doc.Pages.Flatten( + + + + +
client.Doc.Pages.Insert(DocID, LayerName, request) -> *cloudpdf.DocPagesInsert200Response +
+
+ +#### 📝 Description + +
+
+ +
+
+ +Multipart mutation envelope: a `body` field holding `{"destIndex"?: number}` (omitted → append) plus a `resource:source` file part carrying the standalone PDF whose pages are copied in. The inserted copies get fresh page object numbers, returned in insertion order. +
+
+
+
+ +#### 🔌 Usage + +
+
+ +
+
+ +```go +request := &doc.InsertPagesRequest{ + DocID: "docId", + LayerName: "layerName", + File: strings.NewReader( + "", + ), +} +client.Doc.Pages.Insert( + context.TODO(), + request, +) +``` +
+
+
+
+ +#### ⚙️ Parameters + +
+
+ +
+
+ +**docID:** `string` + +
+
+ +
+
+ +**layerName:** `string` + +
+
+ +
+
+ +**documentPassword:** `*string` — Base64-encoded password for an encrypted document. Valid only with the API token (403 anywhere else). An encrypted document answers 422 DocPasswordRequired when the header is absent. Viewer doc JWTs use the SDK password-session flow instead. + +
+
+
+
+ + +
+
+
+ +
client.Doc.Pages.InsertBlank(DocID, LayerName, request) -> *cloudpdf.DocPagesInsertBlank200Response +
+
+ +#### 📝 Description + +
+
+ +
+
+ +Body is `{"size": {"width", "height"}, "count"?, "destIndex"?}` — size in PDF points, count in [1, 100], destIndex omitted → append. +
+
+
+
+ +#### 🔌 Usage + +
+
+ +
+
+ +```go +request := &doc.InsertBlankPagesRequest{ + DocID: "docId", + LayerName: "layerName", + Body: map[string]any{ + "key": "value", + }, +} +client.Doc.Pages.InsertBlank( + context.TODO(), + request, +) +``` +
+
+
+
+ +#### ⚙️ Parameters + +
+
+ +
+
+ +**docID:** `string` + +
+
+ +
+
+ +**layerName:** `string` + +
+
+ +
+
+ +**documentPassword:** `*string` — Base64-encoded password for an encrypted document. Valid only with the API token (403 anywhere else). An encrypted document answers 422 DocPasswordRequired when the header is absent. Viewer doc JWTs use the SDK password-session flow instead. + +
+
+ +
+
+ +**request:** `cloudpdf.DocPagesInsertBlankRequest` + +
+
+
+
+ +
diff --git a/types.go b/types.go index 35239a5..1ef0343 100644 --- a/types.go +++ b/types.go @@ -172142,12 +172142,3384 @@ func (d DocPagesDelete404ResponseName) Ptr() *DocPagesDelete404ResponseName { type DocPagesDeleteRequest = map[string]any +var ( + docPagesExtract400ResponseFieldName = big.NewInt(1 << 0) + docPagesExtract400ResponseFieldCode = big.NewInt(1 << 1) + docPagesExtract400ResponseFieldMessage = big.NewInt(1 << 2) + docPagesExtract400ResponseFieldDetails = big.NewInt(1 << 3) +) + +type DocPagesExtract400Response struct { + Name DocPagesExtract400ResponseName `json:"name" url:"name"` + Code DocPagesExtract400ResponseCode `json:"code" url:"code"` + Message string `json:"message" url:"message"` + Details map[string]any `json:"details,omitempty" url:"details,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 *DocPagesExtract400Response) GetName() DocPagesExtract400ResponseName { + if d == nil { + return "" + } + return d.Name +} + +func (d *DocPagesExtract400Response) GetCode() DocPagesExtract400ResponseCode { + if d == nil { + return "" + } + return d.Code +} + +func (d *DocPagesExtract400Response) GetMessage() string { + if d == nil { + return "" + } + return d.Message +} + +func (d *DocPagesExtract400Response) GetDetails() map[string]any { + if d == nil { + return nil + } + return d.Details +} + +func (d *DocPagesExtract400Response) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesExtract400Response) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetName sets the Name field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesExtract400Response) SetName(name DocPagesExtract400ResponseName) { + d.Name = name + d.require(docPagesExtract400ResponseFieldName) +} + +// SetCode sets the Code field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesExtract400Response) SetCode(code DocPagesExtract400ResponseCode) { + d.Code = code + d.require(docPagesExtract400ResponseFieldCode) +} + +// SetMessage sets the Message field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesExtract400Response) SetMessage(message string) { + d.Message = message + d.require(docPagesExtract400ResponseFieldMessage) +} + +// SetDetails sets the Details field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesExtract400Response) SetDetails(details map[string]any) { + d.Details = details + d.require(docPagesExtract400ResponseFieldDetails) +} + +func (d *DocPagesExtract400Response) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesExtract400Response + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesExtract400Response(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesExtract400Response) MarshalJSON() ([]byte, error) { + type embed DocPagesExtract400Response + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesExtract400Response) String() string { + if d == nil { + return "" + } + 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 DocPagesExtract400ResponseCode string + +const ( + DocPagesExtract400ResponseCodeUnknown DocPagesExtract400ResponseCode = "Unknown" + DocPagesExtract400ResponseCodeInvalidArg DocPagesExtract400ResponseCode = "InvalidArg" + DocPagesExtract400ResponseCodeDocNotOpen DocPagesExtract400ResponseCode = "DocNotOpen" + DocPagesExtract400ResponseCodeDocOpenFailed DocPagesExtract400ResponseCode = "DocOpenFailed" + DocPagesExtract400ResponseCodeDocPasswordRequired DocPagesExtract400ResponseCode = "DocPasswordRequired" + DocPagesExtract400ResponseCodeDocPasswordIncorrect DocPagesExtract400ResponseCode = "DocPasswordIncorrect" + DocPagesExtract400ResponseCodeSharePasswordRequired DocPagesExtract400ResponseCode = "SharePasswordRequired" + DocPagesExtract400ResponseCodeAborted DocPagesExtract400ResponseCode = "Aborted" + DocPagesExtract400ResponseCodeNetwork DocPagesExtract400ResponseCode = "Network" + DocPagesExtract400ResponseCodeUnauthenticated DocPagesExtract400ResponseCode = "Unauthenticated" + DocPagesExtract400ResponseCodeForbidden DocPagesExtract400ResponseCode = "Forbidden" + DocPagesExtract400ResponseCodeNotFound DocPagesExtract400ResponseCode = "NotFound" + DocPagesExtract400ResponseCodeWireFormat DocPagesExtract400ResponseCode = "WireFormat" + DocPagesExtract400ResponseCodeRuntimeUnavailable DocPagesExtract400ResponseCode = "RuntimeUnavailable" + DocPagesExtract400ResponseCodeInvalidReference DocPagesExtract400ResponseCode = "InvalidReference" + DocPagesExtract400ResponseCodeWeakAnnotationSessionConflict DocPagesExtract400ResponseCode = "WeakAnnotationSessionConflict" + DocPagesExtract400ResponseCodeLayerVersionConflict DocPagesExtract400ResponseCode = "LayerVersionConflict" + DocPagesExtract400ResponseCodeNotImplemented DocPagesExtract400ResponseCode = "NotImplemented" + DocPagesExtract400ResponseCodeMalformedPdf DocPagesExtract400ResponseCode = "MalformedPdf" +) + +func NewDocPagesExtract400ResponseCodeFromString(s string) (DocPagesExtract400ResponseCode, error) { + switch s { + case "Unknown": + return DocPagesExtract400ResponseCodeUnknown, nil + case "InvalidArg": + return DocPagesExtract400ResponseCodeInvalidArg, nil + case "DocNotOpen": + return DocPagesExtract400ResponseCodeDocNotOpen, nil + case "DocOpenFailed": + return DocPagesExtract400ResponseCodeDocOpenFailed, nil + case "DocPasswordRequired": + return DocPagesExtract400ResponseCodeDocPasswordRequired, nil + case "DocPasswordIncorrect": + return DocPagesExtract400ResponseCodeDocPasswordIncorrect, nil + case "SharePasswordRequired": + return DocPagesExtract400ResponseCodeSharePasswordRequired, nil + case "Aborted": + return DocPagesExtract400ResponseCodeAborted, nil + case "Network": + return DocPagesExtract400ResponseCodeNetwork, nil + case "Unauthenticated": + return DocPagesExtract400ResponseCodeUnauthenticated, nil + case "Forbidden": + return DocPagesExtract400ResponseCodeForbidden, nil + case "NotFound": + return DocPagesExtract400ResponseCodeNotFound, nil + case "WireFormat": + return DocPagesExtract400ResponseCodeWireFormat, nil + case "RuntimeUnavailable": + return DocPagesExtract400ResponseCodeRuntimeUnavailable, nil + case "InvalidReference": + return DocPagesExtract400ResponseCodeInvalidReference, nil + case "WeakAnnotationSessionConflict": + return DocPagesExtract400ResponseCodeWeakAnnotationSessionConflict, nil + case "LayerVersionConflict": + return DocPagesExtract400ResponseCodeLayerVersionConflict, nil + case "NotImplemented": + return DocPagesExtract400ResponseCodeNotImplemented, nil + case "MalformedPdf": + return DocPagesExtract400ResponseCodeMalformedPdf, nil + } + var t DocPagesExtract400ResponseCode + return "", fmt.Errorf("%s is not a valid %T", s, t) +} + +func (d DocPagesExtract400ResponseCode) Ptr() *DocPagesExtract400ResponseCode { + return &d +} + +type DocPagesExtract400ResponseName string + +const ( + DocPagesExtract400ResponseNameEngineError DocPagesExtract400ResponseName = "EngineError" +) + +func NewDocPagesExtract400ResponseNameFromString(s string) (DocPagesExtract400ResponseName, error) { + switch s { + case "EngineError": + return DocPagesExtract400ResponseNameEngineError, nil + } + var t DocPagesExtract400ResponseName + return "", fmt.Errorf("%s is not a valid %T", s, t) +} + +func (d DocPagesExtract400ResponseName) Ptr() *DocPagesExtract400ResponseName { + return &d +} + +var ( + docPagesExtract404ResponseFieldName = big.NewInt(1 << 0) + docPagesExtract404ResponseFieldCode = big.NewInt(1 << 1) + docPagesExtract404ResponseFieldMessage = big.NewInt(1 << 2) + docPagesExtract404ResponseFieldDetails = big.NewInt(1 << 3) +) + +type DocPagesExtract404Response struct { + Name DocPagesExtract404ResponseName `json:"name" url:"name"` + Code DocPagesExtract404ResponseCode `json:"code" url:"code"` + Message string `json:"message" url:"message"` + Details map[string]any `json:"details,omitempty" url:"details,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 *DocPagesExtract404Response) GetName() DocPagesExtract404ResponseName { + if d == nil { + return "" + } + return d.Name +} + +func (d *DocPagesExtract404Response) GetCode() DocPagesExtract404ResponseCode { + if d == nil { + return "" + } + return d.Code +} + +func (d *DocPagesExtract404Response) GetMessage() string { + if d == nil { + return "" + } + return d.Message +} + +func (d *DocPagesExtract404Response) GetDetails() map[string]any { + if d == nil { + return nil + } + return d.Details +} + +func (d *DocPagesExtract404Response) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesExtract404Response) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetName sets the Name field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesExtract404Response) SetName(name DocPagesExtract404ResponseName) { + d.Name = name + d.require(docPagesExtract404ResponseFieldName) +} + +// SetCode sets the Code field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesExtract404Response) SetCode(code DocPagesExtract404ResponseCode) { + d.Code = code + d.require(docPagesExtract404ResponseFieldCode) +} + +// SetMessage sets the Message field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesExtract404Response) SetMessage(message string) { + d.Message = message + d.require(docPagesExtract404ResponseFieldMessage) +} + +// SetDetails sets the Details field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesExtract404Response) SetDetails(details map[string]any) { + d.Details = details + d.require(docPagesExtract404ResponseFieldDetails) +} + +func (d *DocPagesExtract404Response) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesExtract404Response + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesExtract404Response(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesExtract404Response) MarshalJSON() ([]byte, error) { + type embed DocPagesExtract404Response + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesExtract404Response) String() string { + if d == nil { + return "" + } + 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 DocPagesExtract404ResponseCode string + +const ( + DocPagesExtract404ResponseCodeUnknown DocPagesExtract404ResponseCode = "Unknown" + DocPagesExtract404ResponseCodeInvalidArg DocPagesExtract404ResponseCode = "InvalidArg" + DocPagesExtract404ResponseCodeDocNotOpen DocPagesExtract404ResponseCode = "DocNotOpen" + DocPagesExtract404ResponseCodeDocOpenFailed DocPagesExtract404ResponseCode = "DocOpenFailed" + DocPagesExtract404ResponseCodeDocPasswordRequired DocPagesExtract404ResponseCode = "DocPasswordRequired" + DocPagesExtract404ResponseCodeDocPasswordIncorrect DocPagesExtract404ResponseCode = "DocPasswordIncorrect" + DocPagesExtract404ResponseCodeSharePasswordRequired DocPagesExtract404ResponseCode = "SharePasswordRequired" + DocPagesExtract404ResponseCodeAborted DocPagesExtract404ResponseCode = "Aborted" + DocPagesExtract404ResponseCodeNetwork DocPagesExtract404ResponseCode = "Network" + DocPagesExtract404ResponseCodeUnauthenticated DocPagesExtract404ResponseCode = "Unauthenticated" + DocPagesExtract404ResponseCodeForbidden DocPagesExtract404ResponseCode = "Forbidden" + DocPagesExtract404ResponseCodeNotFound DocPagesExtract404ResponseCode = "NotFound" + DocPagesExtract404ResponseCodeWireFormat DocPagesExtract404ResponseCode = "WireFormat" + DocPagesExtract404ResponseCodeRuntimeUnavailable DocPagesExtract404ResponseCode = "RuntimeUnavailable" + DocPagesExtract404ResponseCodeInvalidReference DocPagesExtract404ResponseCode = "InvalidReference" + DocPagesExtract404ResponseCodeWeakAnnotationSessionConflict DocPagesExtract404ResponseCode = "WeakAnnotationSessionConflict" + DocPagesExtract404ResponseCodeLayerVersionConflict DocPagesExtract404ResponseCode = "LayerVersionConflict" + DocPagesExtract404ResponseCodeNotImplemented DocPagesExtract404ResponseCode = "NotImplemented" + DocPagesExtract404ResponseCodeMalformedPdf DocPagesExtract404ResponseCode = "MalformedPdf" +) + +func NewDocPagesExtract404ResponseCodeFromString(s string) (DocPagesExtract404ResponseCode, error) { + switch s { + case "Unknown": + return DocPagesExtract404ResponseCodeUnknown, nil + case "InvalidArg": + return DocPagesExtract404ResponseCodeInvalidArg, nil + case "DocNotOpen": + return DocPagesExtract404ResponseCodeDocNotOpen, nil + case "DocOpenFailed": + return DocPagesExtract404ResponseCodeDocOpenFailed, nil + case "DocPasswordRequired": + return DocPagesExtract404ResponseCodeDocPasswordRequired, nil + case "DocPasswordIncorrect": + return DocPagesExtract404ResponseCodeDocPasswordIncorrect, nil + case "SharePasswordRequired": + return DocPagesExtract404ResponseCodeSharePasswordRequired, nil + case "Aborted": + return DocPagesExtract404ResponseCodeAborted, nil + case "Network": + return DocPagesExtract404ResponseCodeNetwork, nil + case "Unauthenticated": + return DocPagesExtract404ResponseCodeUnauthenticated, nil + case "Forbidden": + return DocPagesExtract404ResponseCodeForbidden, nil + case "NotFound": + return DocPagesExtract404ResponseCodeNotFound, nil + case "WireFormat": + return DocPagesExtract404ResponseCodeWireFormat, nil + case "RuntimeUnavailable": + return DocPagesExtract404ResponseCodeRuntimeUnavailable, nil + case "InvalidReference": + return DocPagesExtract404ResponseCodeInvalidReference, nil + case "WeakAnnotationSessionConflict": + return DocPagesExtract404ResponseCodeWeakAnnotationSessionConflict, nil + case "LayerVersionConflict": + return DocPagesExtract404ResponseCodeLayerVersionConflict, nil + case "NotImplemented": + return DocPagesExtract404ResponseCodeNotImplemented, nil + case "MalformedPdf": + return DocPagesExtract404ResponseCodeMalformedPdf, nil + } + var t DocPagesExtract404ResponseCode + return "", fmt.Errorf("%s is not a valid %T", s, t) +} + +func (d DocPagesExtract404ResponseCode) Ptr() *DocPagesExtract404ResponseCode { + return &d +} + +type DocPagesExtract404ResponseName string + +const ( + DocPagesExtract404ResponseNameEngineError DocPagesExtract404ResponseName = "EngineError" +) + +func NewDocPagesExtract404ResponseNameFromString(s string) (DocPagesExtract404ResponseName, error) { + switch s { + case "EngineError": + return DocPagesExtract404ResponseNameEngineError, nil + } + var t DocPagesExtract404ResponseName + return "", fmt.Errorf("%s is not a valid %T", s, t) +} + +func (d DocPagesExtract404ResponseName) Ptr() *DocPagesExtract404ResponseName { + return &d +} + +type DocPagesExtractRequest = map[string]any + var ( docPagesFlatten200ResponseFieldMeta = big.NewInt(1 << 0) ) -type DocPagesFlatten200Response struct { - Meta *DocPagesFlatten200ResponseMeta `json:"meta" url:"meta"` +type DocPagesFlatten200Response struct { + Meta *DocPagesFlatten200ResponseMeta `json:"meta" url:"meta"` + + // Private bitmask of fields set to an explicit value and therefore not to be omitted + explicitFields *big.Int `json:"-" url:"-"` + + ExtraProperties map[string]interface{} `json:"-" url:"-"` + + rawJSON json.RawMessage +} + +func (d *DocPagesFlatten200Response) GetMeta() *DocPagesFlatten200ResponseMeta { + if d == nil { + return nil + } + return d.Meta +} + +func (d *DocPagesFlatten200Response) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.ExtraProperties +} + +func (d *DocPagesFlatten200Response) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetMeta sets the Meta field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten200Response) SetMeta(meta *DocPagesFlatten200ResponseMeta) { + d.Meta = meta + d.require(docPagesFlatten200ResponseFieldMeta) +} + +func (d *DocPagesFlatten200Response) UnmarshalJSON(data []byte) error { + type embed DocPagesFlatten200Response + var unmarshaler = struct { + embed + }{ + embed: embed(*d), + } + if err := json.Unmarshal(data, &unmarshaler); err != nil { + return err + } + *d = DocPagesFlatten200Response(unmarshaler.embed) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.ExtraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesFlatten200Response) MarshalJSON() ([]byte, error) { + type embed DocPagesFlatten200Response + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return internal.MarshalJSONWithExtraProperties(explicitMarshaler, d.ExtraProperties) +} + +func (d *DocPagesFlatten200Response) String() string { + if d == nil { + return "" + } + 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 ( + docPagesFlatten200ResponseMetaFieldAffectedPages = big.NewInt(1 << 0) + docPagesFlatten200ResponseMetaFieldCacheDelta = big.NewInt(1 << 1) +) + +type DocPagesFlatten200ResponseMeta struct { + AffectedPages []*DocPagesFlatten200ResponseMetaAffectedPagesItem `json:"affectedPages" url:"affectedPages"` + CacheDelta *DocPagesFlatten200ResponseMetaCacheDelta `json:"cacheDelta,omitempty" url:"cacheDelta,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 *DocPagesFlatten200ResponseMeta) GetAffectedPages() []*DocPagesFlatten200ResponseMetaAffectedPagesItem { + if d == nil { + return nil + } + return d.AffectedPages +} + +func (d *DocPagesFlatten200ResponseMeta) GetCacheDelta() *DocPagesFlatten200ResponseMetaCacheDelta { + if d == nil { + return nil + } + return d.CacheDelta +} + +func (d *DocPagesFlatten200ResponseMeta) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesFlatten200ResponseMeta) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetAffectedPages sets the AffectedPages field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten200ResponseMeta) SetAffectedPages(affectedPages []*DocPagesFlatten200ResponseMetaAffectedPagesItem) { + d.AffectedPages = affectedPages + d.require(docPagesFlatten200ResponseMetaFieldAffectedPages) +} + +// SetCacheDelta sets the CacheDelta field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten200ResponseMeta) SetCacheDelta(cacheDelta *DocPagesFlatten200ResponseMetaCacheDelta) { + d.CacheDelta = cacheDelta + d.require(docPagesFlatten200ResponseMetaFieldCacheDelta) +} + +func (d *DocPagesFlatten200ResponseMeta) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesFlatten200ResponseMeta + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesFlatten200ResponseMeta(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesFlatten200ResponseMeta) MarshalJSON() ([]byte, error) { + type embed DocPagesFlatten200ResponseMeta + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesFlatten200ResponseMeta) String() string { + if d == nil { + return "" + } + 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 ( + docPagesFlatten200ResponseMetaAffectedPagesItemFieldPageObjectNumber = big.NewInt(1 << 0) + docPagesFlatten200ResponseMetaAffectedPagesItemFieldRevision = big.NewInt(1 << 1) + docPagesFlatten200ResponseMetaAffectedPagesItemFieldWeakAnnotationState = big.NewInt(1 << 2) +) + +type DocPagesFlatten200ResponseMetaAffectedPagesItem struct { + PageObjectNumber int `json:"pageObjectNumber" url:"pageObjectNumber"` + Revision *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision `json:"revision" url:"revision"` + WeakAnnotationState *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState `json:"weakAnnotationState" url:"weakAnnotationState"` + + // 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 *DocPagesFlatten200ResponseMetaAffectedPagesItem) GetPageObjectNumber() int { + if d == nil { + return 0 + } + return d.PageObjectNumber +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) GetRevision() *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision { + if d == nil { + return nil + } + return d.Revision +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) GetWeakAnnotationState() *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState { + if d == nil { + return nil + } + return d.WeakAnnotationState +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetPageObjectNumber sets the PageObjectNumber field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) SetPageObjectNumber(pageObjectNumber int) { + d.PageObjectNumber = pageObjectNumber + d.require(docPagesFlatten200ResponseMetaAffectedPagesItemFieldPageObjectNumber) +} + +// 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 *DocPagesFlatten200ResponseMetaAffectedPagesItem) SetRevision(revision *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) { + d.Revision = revision + d.require(docPagesFlatten200ResponseMetaAffectedPagesItemFieldRevision) +} + +// SetWeakAnnotationState sets the WeakAnnotationState field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) SetWeakAnnotationState(weakAnnotationState *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) { + d.WeakAnnotationState = weakAnnotationState + d.require(docPagesFlatten200ResponseMetaAffectedPagesItemFieldWeakAnnotationState) +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesFlatten200ResponseMetaAffectedPagesItem + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesFlatten200ResponseMetaAffectedPagesItem(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) MarshalJSON() ([]byte, error) { + type embed DocPagesFlatten200ResponseMetaAffectedPagesItem + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) String() string { + if d == nil { + return "" + } + 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 ( + docPagesFlatten200ResponseMetaAffectedPagesItemRevisionFieldDocSessionID = big.NewInt(1 << 0) + docPagesFlatten200ResponseMetaAffectedPagesItemRevisionFieldPageObjectNumber = big.NewInt(1 << 1) + docPagesFlatten200ResponseMetaAffectedPagesItemRevisionFieldGeneration = big.NewInt(1 << 2) +) + +type DocPagesFlatten200ResponseMetaAffectedPagesItemRevision struct { + DocSessionID string `json:"docSessionId" url:"docSessionId"` + PageObjectNumber int `json:"pageObjectNumber" url:"pageObjectNumber"` + Generation int `json:"generation" url:"generation"` + + // 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 *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) GetDocSessionID() string { + if d == nil { + return "" + } + return d.DocSessionID +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) GetPageObjectNumber() int { + if d == nil { + return 0 + } + return d.PageObjectNumber +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) GetGeneration() int { + if d == nil { + return 0 + } + return d.Generation +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetDocSessionID sets the DocSessionID field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) SetDocSessionID(docSessionID string) { + d.DocSessionID = docSessionID + d.require(docPagesFlatten200ResponseMetaAffectedPagesItemRevisionFieldDocSessionID) +} + +// SetPageObjectNumber sets the PageObjectNumber field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) SetPageObjectNumber(pageObjectNumber int) { + d.PageObjectNumber = pageObjectNumber + d.require(docPagesFlatten200ResponseMetaAffectedPagesItemRevisionFieldPageObjectNumber) +} + +// SetGeneration sets the Generation field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) SetGeneration(generation int) { + d.Generation = generation + d.require(docPagesFlatten200ResponseMetaAffectedPagesItemRevisionFieldGeneration) +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesFlatten200ResponseMetaAffectedPagesItemRevision + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesFlatten200ResponseMetaAffectedPagesItemRevision(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) MarshalJSON() ([]byte, error) { + type embed DocPagesFlatten200ResponseMetaAffectedPagesItemRevision + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) String() string { + if d == nil { + return "" + } + 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 DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState struct { + Kind string + Unknown *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + Known *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + + rawJSON json.RawMessage +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) GetKind() string { + if d == nil { + return "" + } + return d.Kind +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) GetUnknown() *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown { + if d == nil { + return nil + } + return d.Unknown +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) GetKnown() *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown { + if d == nil { + return nil + } + return d.Known +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) 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 "unknown": + value := new(DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) + if err := json.Unmarshal(data, &value); err != nil { + return err + } + d.Unknown = value + case "known": + value := new(DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) + if err := json.Unmarshal(data, &value); err != nil { + return err + } + d.Known = value + } + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) MarshalJSON() ([]byte, error) { + if err := d.validate(); err != nil { + return nil, err + } + if d.Unknown != nil { + return internal.MarshalJSONWithExtraProperty(d.Unknown, "kind", "unknown") + } + if d.Known != nil { + return internal.MarshalJSONWithExtraProperty(d.Known, "kind", "known") + } + 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 DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateVisitor interface { + VisitUnknown(*DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) error + VisitKnown(*DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) error +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) Accept(visitor DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateVisitor) error { + if d.Unknown != nil { + return visitor.VisitUnknown(d.Unknown) + } + if d.Known != nil { + return visitor.VisitKnown(d.Known) + } + return fmt.Errorf("type %T does not define a non-empty union type", d) +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) validate() error { + if d == nil { + return fmt.Errorf("type %T is nil", d) + } + var fields []string + if d.Unknown != nil { + fields = append(fields, "unknown") + } + if d.Known != nil { + fields = append(fields, "known") + } + 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 ( + docPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnownFieldHasAnyWeakAnnotations = big.NewInt(1 << 0) +) + +type DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown struct { + HasAnyWeakAnnotations bool `json:"hasAnyWeakAnnotations" url:"hasAnyWeakAnnotations"` + + // 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 *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) GetHasAnyWeakAnnotations() bool { + if d == nil { + return false + } + return d.HasAnyWeakAnnotations +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetHasAnyWeakAnnotations sets the HasAnyWeakAnnotations field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) SetHasAnyWeakAnnotations(hasAnyWeakAnnotations bool) { + d.HasAnyWeakAnnotations = hasAnyWeakAnnotations + d.require(docPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnownFieldHasAnyWeakAnnotations) +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) MarshalJSON() ([]byte, error) { + type embed DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) String() string { + if d == nil { + return "" + } + 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 DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown struct { + + // 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 *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) MarshalJSON() ([]byte, error) { + type embed DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) String() string { + if d == nil { + return "" + } + 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 ( + docPagesFlatten200ResponseMetaCacheDeltaFieldPreviousDocVersion = big.NewInt(1 << 0) + docPagesFlatten200ResponseMetaCacheDeltaFieldDocVersion = big.NewInt(1 << 1) + docPagesFlatten200ResponseMetaCacheDeltaFieldPages = big.NewInt(1 << 2) +) + +type DocPagesFlatten200ResponseMetaCacheDelta struct { + PreviousDocVersion int `json:"previousDocVersion" url:"previousDocVersion"` + DocVersion int `json:"docVersion" url:"docVersion"` + Pages []*DocPagesFlatten200ResponseMetaCacheDeltaPagesItem `json:"pages" url:"pages"` + + // 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 *DocPagesFlatten200ResponseMetaCacheDelta) GetPreviousDocVersion() int { + if d == nil { + return 0 + } + return d.PreviousDocVersion +} + +func (d *DocPagesFlatten200ResponseMetaCacheDelta) GetDocVersion() int { + if d == nil { + return 0 + } + return d.DocVersion +} + +func (d *DocPagesFlatten200ResponseMetaCacheDelta) GetPages() []*DocPagesFlatten200ResponseMetaCacheDeltaPagesItem { + if d == nil { + return nil + } + return d.Pages +} + +func (d *DocPagesFlatten200ResponseMetaCacheDelta) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesFlatten200ResponseMetaCacheDelta) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetPreviousDocVersion sets the PreviousDocVersion field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten200ResponseMetaCacheDelta) SetPreviousDocVersion(previousDocVersion int) { + d.PreviousDocVersion = previousDocVersion + d.require(docPagesFlatten200ResponseMetaCacheDeltaFieldPreviousDocVersion) +} + +// SetDocVersion sets the DocVersion field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten200ResponseMetaCacheDelta) SetDocVersion(docVersion int) { + d.DocVersion = docVersion + d.require(docPagesFlatten200ResponseMetaCacheDeltaFieldDocVersion) +} + +// SetPages sets the Pages field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten200ResponseMetaCacheDelta) SetPages(pages []*DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) { + d.Pages = pages + d.require(docPagesFlatten200ResponseMetaCacheDeltaFieldPages) +} + +func (d *DocPagesFlatten200ResponseMetaCacheDelta) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesFlatten200ResponseMetaCacheDelta + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesFlatten200ResponseMetaCacheDelta(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesFlatten200ResponseMetaCacheDelta) MarshalJSON() ([]byte, error) { + type embed DocPagesFlatten200ResponseMetaCacheDelta + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesFlatten200ResponseMetaCacheDelta) String() string { + if d == nil { + return "" + } + 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 ( + docPagesFlatten200ResponseMetaCacheDeltaPagesItemFieldPageObjectNumber = big.NewInt(1 << 0) + docPagesFlatten200ResponseMetaCacheDeltaPagesItemFieldCache = big.NewInt(1 << 1) +) + +type DocPagesFlatten200ResponseMetaCacheDeltaPagesItem struct { + PageObjectNumber int `json:"pageObjectNumber" url:"pageObjectNumber"` + Cache *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache `json:"cache" url:"cache"` + + // 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 *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) GetPageObjectNumber() int { + if d == nil { + return 0 + } + return d.PageObjectNumber +} + +func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) GetCache() *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache { + if d == nil { + return nil + } + return d.Cache +} + +func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetPageObjectNumber sets the PageObjectNumber field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) SetPageObjectNumber(pageObjectNumber int) { + d.PageObjectNumber = pageObjectNumber + d.require(docPagesFlatten200ResponseMetaCacheDeltaPagesItemFieldPageObjectNumber) +} + +// SetCache sets the Cache field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) SetCache(cache *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) { + d.Cache = cache + d.require(docPagesFlatten200ResponseMetaCacheDeltaPagesItemFieldCache) +} + +func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesFlatten200ResponseMetaCacheDeltaPagesItem + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesFlatten200ResponseMetaCacheDeltaPagesItem(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) MarshalJSON() ([]byte, error) { + type embed DocPagesFlatten200ResponseMetaCacheDeltaPagesItem + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) String() string { + if d == nil { + return "" + } + 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 ( + docPagesFlatten200ResponseMetaCacheDeltaPagesItemCacheFieldContentVersion = big.NewInt(1 << 0) + docPagesFlatten200ResponseMetaCacheDeltaPagesItemCacheFieldAnnotationVersion = big.NewInt(1 << 1) +) + +type DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache struct { + ContentVersion int `json:"contentVersion" url:"contentVersion"` + AnnotationVersion int `json:"annotationVersion" url:"annotationVersion"` + + // 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 *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) GetContentVersion() int { + if d == nil { + return 0 + } + return d.ContentVersion +} + +func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) GetAnnotationVersion() int { + if d == nil { + return 0 + } + return d.AnnotationVersion +} + +func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetContentVersion sets the ContentVersion field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) SetContentVersion(contentVersion int) { + d.ContentVersion = contentVersion + d.require(docPagesFlatten200ResponseMetaCacheDeltaPagesItemCacheFieldContentVersion) +} + +// SetAnnotationVersion sets the AnnotationVersion field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) SetAnnotationVersion(annotationVersion int) { + d.AnnotationVersion = annotationVersion + d.require(docPagesFlatten200ResponseMetaCacheDeltaPagesItemCacheFieldAnnotationVersion) +} + +func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) MarshalJSON() ([]byte, error) { + type embed DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) String() string { + if d == nil { + return "" + } + 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 ( + docPagesFlatten400ResponseFieldName = big.NewInt(1 << 0) + docPagesFlatten400ResponseFieldCode = big.NewInt(1 << 1) + docPagesFlatten400ResponseFieldMessage = big.NewInt(1 << 2) + docPagesFlatten400ResponseFieldDetails = big.NewInt(1 << 3) +) + +type DocPagesFlatten400Response struct { + Name DocPagesFlatten400ResponseName `json:"name" url:"name"` + Code DocPagesFlatten400ResponseCode `json:"code" url:"code"` + Message string `json:"message" url:"message"` + Details map[string]any `json:"details,omitempty" url:"details,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 *DocPagesFlatten400Response) GetName() DocPagesFlatten400ResponseName { + if d == nil { + return "" + } + return d.Name +} + +func (d *DocPagesFlatten400Response) GetCode() DocPagesFlatten400ResponseCode { + if d == nil { + return "" + } + return d.Code +} + +func (d *DocPagesFlatten400Response) GetMessage() string { + if d == nil { + return "" + } + return d.Message +} + +func (d *DocPagesFlatten400Response) GetDetails() map[string]any { + if d == nil { + return nil + } + return d.Details +} + +func (d *DocPagesFlatten400Response) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesFlatten400Response) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetName sets the Name field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten400Response) SetName(name DocPagesFlatten400ResponseName) { + d.Name = name + d.require(docPagesFlatten400ResponseFieldName) +} + +// SetCode sets the Code field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten400Response) SetCode(code DocPagesFlatten400ResponseCode) { + d.Code = code + d.require(docPagesFlatten400ResponseFieldCode) +} + +// SetMessage sets the Message field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten400Response) SetMessage(message string) { + d.Message = message + d.require(docPagesFlatten400ResponseFieldMessage) +} + +// SetDetails sets the Details field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten400Response) SetDetails(details map[string]any) { + d.Details = details + d.require(docPagesFlatten400ResponseFieldDetails) +} + +func (d *DocPagesFlatten400Response) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesFlatten400Response + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesFlatten400Response(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesFlatten400Response) MarshalJSON() ([]byte, error) { + type embed DocPagesFlatten400Response + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesFlatten400Response) String() string { + if d == nil { + return "" + } + 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 DocPagesFlatten400ResponseCode string + +const ( + DocPagesFlatten400ResponseCodeUnknown DocPagesFlatten400ResponseCode = "Unknown" + DocPagesFlatten400ResponseCodeInvalidArg DocPagesFlatten400ResponseCode = "InvalidArg" + DocPagesFlatten400ResponseCodeDocNotOpen DocPagesFlatten400ResponseCode = "DocNotOpen" + DocPagesFlatten400ResponseCodeDocOpenFailed DocPagesFlatten400ResponseCode = "DocOpenFailed" + DocPagesFlatten400ResponseCodeDocPasswordRequired DocPagesFlatten400ResponseCode = "DocPasswordRequired" + DocPagesFlatten400ResponseCodeDocPasswordIncorrect DocPagesFlatten400ResponseCode = "DocPasswordIncorrect" + DocPagesFlatten400ResponseCodeSharePasswordRequired DocPagesFlatten400ResponseCode = "SharePasswordRequired" + DocPagesFlatten400ResponseCodeAborted DocPagesFlatten400ResponseCode = "Aborted" + DocPagesFlatten400ResponseCodeNetwork DocPagesFlatten400ResponseCode = "Network" + DocPagesFlatten400ResponseCodeUnauthenticated DocPagesFlatten400ResponseCode = "Unauthenticated" + DocPagesFlatten400ResponseCodeForbidden DocPagesFlatten400ResponseCode = "Forbidden" + DocPagesFlatten400ResponseCodeNotFound DocPagesFlatten400ResponseCode = "NotFound" + DocPagesFlatten400ResponseCodeWireFormat DocPagesFlatten400ResponseCode = "WireFormat" + DocPagesFlatten400ResponseCodeRuntimeUnavailable DocPagesFlatten400ResponseCode = "RuntimeUnavailable" + DocPagesFlatten400ResponseCodeInvalidReference DocPagesFlatten400ResponseCode = "InvalidReference" + DocPagesFlatten400ResponseCodeWeakAnnotationSessionConflict DocPagesFlatten400ResponseCode = "WeakAnnotationSessionConflict" + DocPagesFlatten400ResponseCodeLayerVersionConflict DocPagesFlatten400ResponseCode = "LayerVersionConflict" + DocPagesFlatten400ResponseCodeNotImplemented DocPagesFlatten400ResponseCode = "NotImplemented" + DocPagesFlatten400ResponseCodeMalformedPdf DocPagesFlatten400ResponseCode = "MalformedPdf" +) + +func NewDocPagesFlatten400ResponseCodeFromString(s string) (DocPagesFlatten400ResponseCode, error) { + switch s { + case "Unknown": + return DocPagesFlatten400ResponseCodeUnknown, nil + case "InvalidArg": + return DocPagesFlatten400ResponseCodeInvalidArg, nil + case "DocNotOpen": + return DocPagesFlatten400ResponseCodeDocNotOpen, nil + case "DocOpenFailed": + return DocPagesFlatten400ResponseCodeDocOpenFailed, nil + case "DocPasswordRequired": + return DocPagesFlatten400ResponseCodeDocPasswordRequired, nil + case "DocPasswordIncorrect": + return DocPagesFlatten400ResponseCodeDocPasswordIncorrect, nil + case "SharePasswordRequired": + return DocPagesFlatten400ResponseCodeSharePasswordRequired, nil + case "Aborted": + return DocPagesFlatten400ResponseCodeAborted, nil + case "Network": + return DocPagesFlatten400ResponseCodeNetwork, nil + case "Unauthenticated": + return DocPagesFlatten400ResponseCodeUnauthenticated, nil + case "Forbidden": + return DocPagesFlatten400ResponseCodeForbidden, nil + case "NotFound": + return DocPagesFlatten400ResponseCodeNotFound, nil + case "WireFormat": + return DocPagesFlatten400ResponseCodeWireFormat, nil + case "RuntimeUnavailable": + return DocPagesFlatten400ResponseCodeRuntimeUnavailable, nil + case "InvalidReference": + return DocPagesFlatten400ResponseCodeInvalidReference, nil + case "WeakAnnotationSessionConflict": + return DocPagesFlatten400ResponseCodeWeakAnnotationSessionConflict, nil + case "LayerVersionConflict": + return DocPagesFlatten400ResponseCodeLayerVersionConflict, nil + case "NotImplemented": + return DocPagesFlatten400ResponseCodeNotImplemented, nil + case "MalformedPdf": + return DocPagesFlatten400ResponseCodeMalformedPdf, nil + } + var t DocPagesFlatten400ResponseCode + return "", fmt.Errorf("%s is not a valid %T", s, t) +} + +func (d DocPagesFlatten400ResponseCode) Ptr() *DocPagesFlatten400ResponseCode { + return &d +} + +type DocPagesFlatten400ResponseName string + +const ( + DocPagesFlatten400ResponseNameEngineError DocPagesFlatten400ResponseName = "EngineError" +) + +func NewDocPagesFlatten400ResponseNameFromString(s string) (DocPagesFlatten400ResponseName, error) { + switch s { + case "EngineError": + return DocPagesFlatten400ResponseNameEngineError, nil + } + var t DocPagesFlatten400ResponseName + return "", fmt.Errorf("%s is not a valid %T", s, t) +} + +func (d DocPagesFlatten400ResponseName) Ptr() *DocPagesFlatten400ResponseName { + return &d +} + +var ( + docPagesFlatten404ResponseFieldName = big.NewInt(1 << 0) + docPagesFlatten404ResponseFieldCode = big.NewInt(1 << 1) + docPagesFlatten404ResponseFieldMessage = big.NewInt(1 << 2) + docPagesFlatten404ResponseFieldDetails = big.NewInt(1 << 3) +) + +type DocPagesFlatten404Response struct { + Name DocPagesFlatten404ResponseName `json:"name" url:"name"` + Code DocPagesFlatten404ResponseCode `json:"code" url:"code"` + Message string `json:"message" url:"message"` + Details map[string]any `json:"details,omitempty" url:"details,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 *DocPagesFlatten404Response) GetName() DocPagesFlatten404ResponseName { + if d == nil { + return "" + } + return d.Name +} + +func (d *DocPagesFlatten404Response) GetCode() DocPagesFlatten404ResponseCode { + if d == nil { + return "" + } + return d.Code +} + +func (d *DocPagesFlatten404Response) GetMessage() string { + if d == nil { + return "" + } + return d.Message +} + +func (d *DocPagesFlatten404Response) GetDetails() map[string]any { + if d == nil { + return nil + } + return d.Details +} + +func (d *DocPagesFlatten404Response) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesFlatten404Response) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetName sets the Name field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten404Response) SetName(name DocPagesFlatten404ResponseName) { + d.Name = name + d.require(docPagesFlatten404ResponseFieldName) +} + +// SetCode sets the Code field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten404Response) SetCode(code DocPagesFlatten404ResponseCode) { + d.Code = code + d.require(docPagesFlatten404ResponseFieldCode) +} + +// SetMessage sets the Message field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten404Response) SetMessage(message string) { + d.Message = message + d.require(docPagesFlatten404ResponseFieldMessage) +} + +// SetDetails sets the Details field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesFlatten404Response) SetDetails(details map[string]any) { + d.Details = details + d.require(docPagesFlatten404ResponseFieldDetails) +} + +func (d *DocPagesFlatten404Response) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesFlatten404Response + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesFlatten404Response(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesFlatten404Response) MarshalJSON() ([]byte, error) { + type embed DocPagesFlatten404Response + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesFlatten404Response) String() string { + if d == nil { + return "" + } + 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 DocPagesFlatten404ResponseCode string + +const ( + DocPagesFlatten404ResponseCodeUnknown DocPagesFlatten404ResponseCode = "Unknown" + DocPagesFlatten404ResponseCodeInvalidArg DocPagesFlatten404ResponseCode = "InvalidArg" + DocPagesFlatten404ResponseCodeDocNotOpen DocPagesFlatten404ResponseCode = "DocNotOpen" + DocPagesFlatten404ResponseCodeDocOpenFailed DocPagesFlatten404ResponseCode = "DocOpenFailed" + DocPagesFlatten404ResponseCodeDocPasswordRequired DocPagesFlatten404ResponseCode = "DocPasswordRequired" + DocPagesFlatten404ResponseCodeDocPasswordIncorrect DocPagesFlatten404ResponseCode = "DocPasswordIncorrect" + DocPagesFlatten404ResponseCodeSharePasswordRequired DocPagesFlatten404ResponseCode = "SharePasswordRequired" + DocPagesFlatten404ResponseCodeAborted DocPagesFlatten404ResponseCode = "Aborted" + DocPagesFlatten404ResponseCodeNetwork DocPagesFlatten404ResponseCode = "Network" + DocPagesFlatten404ResponseCodeUnauthenticated DocPagesFlatten404ResponseCode = "Unauthenticated" + DocPagesFlatten404ResponseCodeForbidden DocPagesFlatten404ResponseCode = "Forbidden" + DocPagesFlatten404ResponseCodeNotFound DocPagesFlatten404ResponseCode = "NotFound" + DocPagesFlatten404ResponseCodeWireFormat DocPagesFlatten404ResponseCode = "WireFormat" + DocPagesFlatten404ResponseCodeRuntimeUnavailable DocPagesFlatten404ResponseCode = "RuntimeUnavailable" + DocPagesFlatten404ResponseCodeInvalidReference DocPagesFlatten404ResponseCode = "InvalidReference" + DocPagesFlatten404ResponseCodeWeakAnnotationSessionConflict DocPagesFlatten404ResponseCode = "WeakAnnotationSessionConflict" + DocPagesFlatten404ResponseCodeLayerVersionConflict DocPagesFlatten404ResponseCode = "LayerVersionConflict" + DocPagesFlatten404ResponseCodeNotImplemented DocPagesFlatten404ResponseCode = "NotImplemented" + DocPagesFlatten404ResponseCodeMalformedPdf DocPagesFlatten404ResponseCode = "MalformedPdf" +) + +func NewDocPagesFlatten404ResponseCodeFromString(s string) (DocPagesFlatten404ResponseCode, error) { + switch s { + case "Unknown": + return DocPagesFlatten404ResponseCodeUnknown, nil + case "InvalidArg": + return DocPagesFlatten404ResponseCodeInvalidArg, nil + case "DocNotOpen": + return DocPagesFlatten404ResponseCodeDocNotOpen, nil + case "DocOpenFailed": + return DocPagesFlatten404ResponseCodeDocOpenFailed, nil + case "DocPasswordRequired": + return DocPagesFlatten404ResponseCodeDocPasswordRequired, nil + case "DocPasswordIncorrect": + return DocPagesFlatten404ResponseCodeDocPasswordIncorrect, nil + case "SharePasswordRequired": + return DocPagesFlatten404ResponseCodeSharePasswordRequired, nil + case "Aborted": + return DocPagesFlatten404ResponseCodeAborted, nil + case "Network": + return DocPagesFlatten404ResponseCodeNetwork, nil + case "Unauthenticated": + return DocPagesFlatten404ResponseCodeUnauthenticated, nil + case "Forbidden": + return DocPagesFlatten404ResponseCodeForbidden, nil + case "NotFound": + return DocPagesFlatten404ResponseCodeNotFound, nil + case "WireFormat": + return DocPagesFlatten404ResponseCodeWireFormat, nil + case "RuntimeUnavailable": + return DocPagesFlatten404ResponseCodeRuntimeUnavailable, nil + case "InvalidReference": + return DocPagesFlatten404ResponseCodeInvalidReference, nil + case "WeakAnnotationSessionConflict": + return DocPagesFlatten404ResponseCodeWeakAnnotationSessionConflict, nil + case "LayerVersionConflict": + return DocPagesFlatten404ResponseCodeLayerVersionConflict, nil + case "NotImplemented": + return DocPagesFlatten404ResponseCodeNotImplemented, nil + case "MalformedPdf": + return DocPagesFlatten404ResponseCodeMalformedPdf, nil + } + var t DocPagesFlatten404ResponseCode + return "", fmt.Errorf("%s is not a valid %T", s, t) +} + +func (d DocPagesFlatten404ResponseCode) Ptr() *DocPagesFlatten404ResponseCode { + return &d +} + +type DocPagesFlatten404ResponseName string + +const ( + DocPagesFlatten404ResponseNameEngineError DocPagesFlatten404ResponseName = "EngineError" +) + +func NewDocPagesFlatten404ResponseNameFromString(s string) (DocPagesFlatten404ResponseName, error) { + switch s { + case "EngineError": + return DocPagesFlatten404ResponseNameEngineError, nil + } + var t DocPagesFlatten404ResponseName + return "", fmt.Errorf("%s is not a valid %T", s, t) +} + +func (d DocPagesFlatten404ResponseName) Ptr() *DocPagesFlatten404ResponseName { + return &d +} + +type DocPagesFlattenRequest = map[string]any + +var ( + docPagesInsert200ResponseFieldMeta = big.NewInt(1 << 0) +) + +type DocPagesInsert200Response struct { + Meta *DocPagesInsert200ResponseMeta `json:"meta" url:"meta"` + + // Private bitmask of fields set to an explicit value and therefore not to be omitted + explicitFields *big.Int `json:"-" url:"-"` + + ExtraProperties map[string]interface{} `json:"-" url:"-"` + + rawJSON json.RawMessage +} + +func (d *DocPagesInsert200Response) GetMeta() *DocPagesInsert200ResponseMeta { + if d == nil { + return nil + } + return d.Meta +} + +func (d *DocPagesInsert200Response) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.ExtraProperties +} + +func (d *DocPagesInsert200Response) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetMeta sets the Meta field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert200Response) SetMeta(meta *DocPagesInsert200ResponseMeta) { + d.Meta = meta + d.require(docPagesInsert200ResponseFieldMeta) +} + +func (d *DocPagesInsert200Response) UnmarshalJSON(data []byte) error { + type embed DocPagesInsert200Response + var unmarshaler = struct { + embed + }{ + embed: embed(*d), + } + if err := json.Unmarshal(data, &unmarshaler); err != nil { + return err + } + *d = DocPagesInsert200Response(unmarshaler.embed) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.ExtraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesInsert200Response) MarshalJSON() ([]byte, error) { + type embed DocPagesInsert200Response + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return internal.MarshalJSONWithExtraProperties(explicitMarshaler, d.ExtraProperties) +} + +func (d *DocPagesInsert200Response) String() string { + if d == nil { + return "" + } + 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 ( + docPagesInsert200ResponseMetaFieldAffectedPages = big.NewInt(1 << 0) + docPagesInsert200ResponseMetaFieldCacheDelta = big.NewInt(1 << 1) +) + +type DocPagesInsert200ResponseMeta struct { + AffectedPages []*DocPagesInsert200ResponseMetaAffectedPagesItem `json:"affectedPages" url:"affectedPages"` + CacheDelta *DocPagesInsert200ResponseMetaCacheDelta `json:"cacheDelta,omitempty" url:"cacheDelta,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 *DocPagesInsert200ResponseMeta) GetAffectedPages() []*DocPagesInsert200ResponseMetaAffectedPagesItem { + if d == nil { + return nil + } + return d.AffectedPages +} + +func (d *DocPagesInsert200ResponseMeta) GetCacheDelta() *DocPagesInsert200ResponseMetaCacheDelta { + if d == nil { + return nil + } + return d.CacheDelta +} + +func (d *DocPagesInsert200ResponseMeta) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesInsert200ResponseMeta) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetAffectedPages sets the AffectedPages field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert200ResponseMeta) SetAffectedPages(affectedPages []*DocPagesInsert200ResponseMetaAffectedPagesItem) { + d.AffectedPages = affectedPages + d.require(docPagesInsert200ResponseMetaFieldAffectedPages) +} + +// SetCacheDelta sets the CacheDelta field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert200ResponseMeta) SetCacheDelta(cacheDelta *DocPagesInsert200ResponseMetaCacheDelta) { + d.CacheDelta = cacheDelta + d.require(docPagesInsert200ResponseMetaFieldCacheDelta) +} + +func (d *DocPagesInsert200ResponseMeta) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsert200ResponseMeta + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesInsert200ResponseMeta(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesInsert200ResponseMeta) MarshalJSON() ([]byte, error) { + type embed DocPagesInsert200ResponseMeta + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesInsert200ResponseMeta) String() string { + if d == nil { + return "" + } + 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 ( + docPagesInsert200ResponseMetaAffectedPagesItemFieldPageObjectNumber = big.NewInt(1 << 0) + docPagesInsert200ResponseMetaAffectedPagesItemFieldRevision = big.NewInt(1 << 1) + docPagesInsert200ResponseMetaAffectedPagesItemFieldWeakAnnotationState = big.NewInt(1 << 2) +) + +type DocPagesInsert200ResponseMetaAffectedPagesItem struct { + PageObjectNumber int `json:"pageObjectNumber" url:"pageObjectNumber"` + Revision *DocPagesInsert200ResponseMetaAffectedPagesItemRevision `json:"revision" url:"revision"` + WeakAnnotationState *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState `json:"weakAnnotationState" url:"weakAnnotationState"` + + // 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 *DocPagesInsert200ResponseMetaAffectedPagesItem) GetPageObjectNumber() int { + if d == nil { + return 0 + } + return d.PageObjectNumber +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItem) GetRevision() *DocPagesInsert200ResponseMetaAffectedPagesItemRevision { + if d == nil { + return nil + } + return d.Revision +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItem) GetWeakAnnotationState() *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState { + if d == nil { + return nil + } + return d.WeakAnnotationState +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItem) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItem) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetPageObjectNumber sets the PageObjectNumber field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert200ResponseMetaAffectedPagesItem) SetPageObjectNumber(pageObjectNumber int) { + d.PageObjectNumber = pageObjectNumber + d.require(docPagesInsert200ResponseMetaAffectedPagesItemFieldPageObjectNumber) +} + +// 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 *DocPagesInsert200ResponseMetaAffectedPagesItem) SetRevision(revision *DocPagesInsert200ResponseMetaAffectedPagesItemRevision) { + d.Revision = revision + d.require(docPagesInsert200ResponseMetaAffectedPagesItemFieldRevision) +} + +// SetWeakAnnotationState sets the WeakAnnotationState field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert200ResponseMetaAffectedPagesItem) SetWeakAnnotationState(weakAnnotationState *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState) { + d.WeakAnnotationState = weakAnnotationState + d.require(docPagesInsert200ResponseMetaAffectedPagesItemFieldWeakAnnotationState) +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItem) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsert200ResponseMetaAffectedPagesItem + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesInsert200ResponseMetaAffectedPagesItem(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItem) MarshalJSON() ([]byte, error) { + type embed DocPagesInsert200ResponseMetaAffectedPagesItem + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItem) String() string { + if d == nil { + return "" + } + 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 ( + docPagesInsert200ResponseMetaAffectedPagesItemRevisionFieldDocSessionID = big.NewInt(1 << 0) + docPagesInsert200ResponseMetaAffectedPagesItemRevisionFieldPageObjectNumber = big.NewInt(1 << 1) + docPagesInsert200ResponseMetaAffectedPagesItemRevisionFieldGeneration = big.NewInt(1 << 2) +) + +type DocPagesInsert200ResponseMetaAffectedPagesItemRevision struct { + DocSessionID string `json:"docSessionId" url:"docSessionId"` + PageObjectNumber int `json:"pageObjectNumber" url:"pageObjectNumber"` + Generation int `json:"generation" url:"generation"` + + // 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 *DocPagesInsert200ResponseMetaAffectedPagesItemRevision) GetDocSessionID() string { + if d == nil { + return "" + } + return d.DocSessionID +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemRevision) GetPageObjectNumber() int { + if d == nil { + return 0 + } + return d.PageObjectNumber +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemRevision) GetGeneration() int { + if d == nil { + return 0 + } + return d.Generation +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemRevision) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemRevision) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetDocSessionID sets the DocSessionID field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemRevision) SetDocSessionID(docSessionID string) { + d.DocSessionID = docSessionID + d.require(docPagesInsert200ResponseMetaAffectedPagesItemRevisionFieldDocSessionID) +} + +// SetPageObjectNumber sets the PageObjectNumber field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemRevision) SetPageObjectNumber(pageObjectNumber int) { + d.PageObjectNumber = pageObjectNumber + d.require(docPagesInsert200ResponseMetaAffectedPagesItemRevisionFieldPageObjectNumber) +} + +// SetGeneration sets the Generation field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemRevision) SetGeneration(generation int) { + d.Generation = generation + d.require(docPagesInsert200ResponseMetaAffectedPagesItemRevisionFieldGeneration) +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemRevision) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsert200ResponseMetaAffectedPagesItemRevision + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesInsert200ResponseMetaAffectedPagesItemRevision(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemRevision) MarshalJSON() ([]byte, error) { + type embed DocPagesInsert200ResponseMetaAffectedPagesItemRevision + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemRevision) String() string { + if d == nil { + return "" + } + 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 DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState struct { + Kind string + Unknown *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + Known *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + + rawJSON json.RawMessage +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState) GetKind() string { + if d == nil { + return "" + } + return d.Kind +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState) GetUnknown() *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown { + if d == nil { + return nil + } + return d.Unknown +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState) GetKnown() *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown { + if d == nil { + return nil + } + return d.Known +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState) 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 "unknown": + value := new(DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) + if err := json.Unmarshal(data, &value); err != nil { + return err + } + d.Unknown = value + case "known": + value := new(DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) + if err := json.Unmarshal(data, &value); err != nil { + return err + } + d.Known = value + } + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState) MarshalJSON() ([]byte, error) { + if err := d.validate(); err != nil { + return nil, err + } + if d.Unknown != nil { + return internal.MarshalJSONWithExtraProperty(d.Unknown, "kind", "unknown") + } + if d.Known != nil { + return internal.MarshalJSONWithExtraProperty(d.Known, "kind", "known") + } + 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 DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateVisitor interface { + VisitUnknown(*DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) error + VisitKnown(*DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) error +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState) Accept(visitor DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateVisitor) error { + if d.Unknown != nil { + return visitor.VisitUnknown(d.Unknown) + } + if d.Known != nil { + return visitor.VisitKnown(d.Known) + } + return fmt.Errorf("type %T does not define a non-empty union type", d) +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState) validate() error { + if d == nil { + return fmt.Errorf("type %T is nil", d) + } + var fields []string + if d.Unknown != nil { + fields = append(fields, "unknown") + } + if d.Known != nil { + fields = append(fields, "known") + } + 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 ( + docPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnownFieldHasAnyWeakAnnotations = big.NewInt(1 << 0) +) + +type DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown struct { + HasAnyWeakAnnotations bool `json:"hasAnyWeakAnnotations" url:"hasAnyWeakAnnotations"` + + // 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 *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) GetHasAnyWeakAnnotations() bool { + if d == nil { + return false + } + return d.HasAnyWeakAnnotations +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetHasAnyWeakAnnotations sets the HasAnyWeakAnnotations field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) SetHasAnyWeakAnnotations(hasAnyWeakAnnotations bool) { + d.HasAnyWeakAnnotations = hasAnyWeakAnnotations + d.require(docPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnownFieldHasAnyWeakAnnotations) +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) MarshalJSON() ([]byte, error) { + type embed DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) String() string { + if d == nil { + return "" + } + 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 DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown struct { + + // 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 *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) MarshalJSON() ([]byte, error) { + type embed DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) String() string { + if d == nil { + return "" + } + 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 ( + docPagesInsert200ResponseMetaCacheDeltaFieldPreviousDocVersion = big.NewInt(1 << 0) + docPagesInsert200ResponseMetaCacheDeltaFieldDocVersion = big.NewInt(1 << 1) + docPagesInsert200ResponseMetaCacheDeltaFieldPages = big.NewInt(1 << 2) +) + +type DocPagesInsert200ResponseMetaCacheDelta struct { + PreviousDocVersion int `json:"previousDocVersion" url:"previousDocVersion"` + DocVersion int `json:"docVersion" url:"docVersion"` + Pages []*DocPagesInsert200ResponseMetaCacheDeltaPagesItem `json:"pages" url:"pages"` + + // 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 *DocPagesInsert200ResponseMetaCacheDelta) GetPreviousDocVersion() int { + if d == nil { + return 0 + } + return d.PreviousDocVersion +} + +func (d *DocPagesInsert200ResponseMetaCacheDelta) GetDocVersion() int { + if d == nil { + return 0 + } + return d.DocVersion +} + +func (d *DocPagesInsert200ResponseMetaCacheDelta) GetPages() []*DocPagesInsert200ResponseMetaCacheDeltaPagesItem { + if d == nil { + return nil + } + return d.Pages +} + +func (d *DocPagesInsert200ResponseMetaCacheDelta) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesInsert200ResponseMetaCacheDelta) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetPreviousDocVersion sets the PreviousDocVersion field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert200ResponseMetaCacheDelta) SetPreviousDocVersion(previousDocVersion int) { + d.PreviousDocVersion = previousDocVersion + d.require(docPagesInsert200ResponseMetaCacheDeltaFieldPreviousDocVersion) +} + +// SetDocVersion sets the DocVersion field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert200ResponseMetaCacheDelta) SetDocVersion(docVersion int) { + d.DocVersion = docVersion + d.require(docPagesInsert200ResponseMetaCacheDeltaFieldDocVersion) +} + +// SetPages sets the Pages field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert200ResponseMetaCacheDelta) SetPages(pages []*DocPagesInsert200ResponseMetaCacheDeltaPagesItem) { + d.Pages = pages + d.require(docPagesInsert200ResponseMetaCacheDeltaFieldPages) +} + +func (d *DocPagesInsert200ResponseMetaCacheDelta) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsert200ResponseMetaCacheDelta + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesInsert200ResponseMetaCacheDelta(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesInsert200ResponseMetaCacheDelta) MarshalJSON() ([]byte, error) { + type embed DocPagesInsert200ResponseMetaCacheDelta + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesInsert200ResponseMetaCacheDelta) String() string { + if d == nil { + return "" + } + 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 ( + docPagesInsert200ResponseMetaCacheDeltaPagesItemFieldPageObjectNumber = big.NewInt(1 << 0) + docPagesInsert200ResponseMetaCacheDeltaPagesItemFieldCache = big.NewInt(1 << 1) +) + +type DocPagesInsert200ResponseMetaCacheDeltaPagesItem struct { + PageObjectNumber int `json:"pageObjectNumber" url:"pageObjectNumber"` + Cache *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache `json:"cache" url:"cache"` + + // 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 *DocPagesInsert200ResponseMetaCacheDeltaPagesItem) GetPageObjectNumber() int { + if d == nil { + return 0 + } + return d.PageObjectNumber +} + +func (d *DocPagesInsert200ResponseMetaCacheDeltaPagesItem) GetCache() *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache { + if d == nil { + return nil + } + return d.Cache +} + +func (d *DocPagesInsert200ResponseMetaCacheDeltaPagesItem) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesInsert200ResponseMetaCacheDeltaPagesItem) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetPageObjectNumber sets the PageObjectNumber field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert200ResponseMetaCacheDeltaPagesItem) SetPageObjectNumber(pageObjectNumber int) { + d.PageObjectNumber = pageObjectNumber + d.require(docPagesInsert200ResponseMetaCacheDeltaPagesItemFieldPageObjectNumber) +} + +// SetCache sets the Cache field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert200ResponseMetaCacheDeltaPagesItem) SetCache(cache *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache) { + d.Cache = cache + d.require(docPagesInsert200ResponseMetaCacheDeltaPagesItemFieldCache) +} + +func (d *DocPagesInsert200ResponseMetaCacheDeltaPagesItem) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsert200ResponseMetaCacheDeltaPagesItem + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesInsert200ResponseMetaCacheDeltaPagesItem(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesInsert200ResponseMetaCacheDeltaPagesItem) MarshalJSON() ([]byte, error) { + type embed DocPagesInsert200ResponseMetaCacheDeltaPagesItem + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesInsert200ResponseMetaCacheDeltaPagesItem) String() string { + if d == nil { + return "" + } + 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 ( + docPagesInsert200ResponseMetaCacheDeltaPagesItemCacheFieldContentVersion = big.NewInt(1 << 0) + docPagesInsert200ResponseMetaCacheDeltaPagesItemCacheFieldAnnotationVersion = big.NewInt(1 << 1) +) + +type DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache struct { + ContentVersion int `json:"contentVersion" url:"contentVersion"` + AnnotationVersion int `json:"annotationVersion" url:"annotationVersion"` + + // 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 *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache) GetContentVersion() int { + if d == nil { + return 0 + } + return d.ContentVersion +} + +func (d *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache) GetAnnotationVersion() int { + if d == nil { + return 0 + } + return d.AnnotationVersion +} + +func (d *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetContentVersion sets the ContentVersion field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache) SetContentVersion(contentVersion int) { + d.ContentVersion = contentVersion + d.require(docPagesInsert200ResponseMetaCacheDeltaPagesItemCacheFieldContentVersion) +} + +// SetAnnotationVersion sets the AnnotationVersion field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache) SetAnnotationVersion(annotationVersion int) { + d.AnnotationVersion = annotationVersion + d.require(docPagesInsert200ResponseMetaCacheDeltaPagesItemCacheFieldAnnotationVersion) +} + +func (d *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache) MarshalJSON() ([]byte, error) { + type embed DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache) String() string { + if d == nil { + return "" + } + 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 ( + docPagesInsert400ResponseFieldName = big.NewInt(1 << 0) + docPagesInsert400ResponseFieldCode = big.NewInt(1 << 1) + docPagesInsert400ResponseFieldMessage = big.NewInt(1 << 2) + docPagesInsert400ResponseFieldDetails = big.NewInt(1 << 3) +) + +type DocPagesInsert400Response struct { + Name DocPagesInsert400ResponseName `json:"name" url:"name"` + Code DocPagesInsert400ResponseCode `json:"code" url:"code"` + Message string `json:"message" url:"message"` + Details map[string]any `json:"details,omitempty" url:"details,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 *DocPagesInsert400Response) GetName() DocPagesInsert400ResponseName { + if d == nil { + return "" + } + return d.Name +} + +func (d *DocPagesInsert400Response) GetCode() DocPagesInsert400ResponseCode { + if d == nil { + return "" + } + return d.Code +} + +func (d *DocPagesInsert400Response) GetMessage() string { + if d == nil { + return "" + } + return d.Message +} + +func (d *DocPagesInsert400Response) GetDetails() map[string]any { + if d == nil { + return nil + } + return d.Details +} + +func (d *DocPagesInsert400Response) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesInsert400Response) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetName sets the Name field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert400Response) SetName(name DocPagesInsert400ResponseName) { + d.Name = name + d.require(docPagesInsert400ResponseFieldName) +} + +// SetCode sets the Code field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert400Response) SetCode(code DocPagesInsert400ResponseCode) { + d.Code = code + d.require(docPagesInsert400ResponseFieldCode) +} + +// SetMessage sets the Message field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert400Response) SetMessage(message string) { + d.Message = message + d.require(docPagesInsert400ResponseFieldMessage) +} + +// SetDetails sets the Details field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert400Response) SetDetails(details map[string]any) { + d.Details = details + d.require(docPagesInsert400ResponseFieldDetails) +} + +func (d *DocPagesInsert400Response) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsert400Response + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesInsert400Response(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesInsert400Response) MarshalJSON() ([]byte, error) { + type embed DocPagesInsert400Response + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesInsert400Response) String() string { + if d == nil { + return "" + } + 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 DocPagesInsert400ResponseCode string + +const ( + DocPagesInsert400ResponseCodeUnknown DocPagesInsert400ResponseCode = "Unknown" + DocPagesInsert400ResponseCodeInvalidArg DocPagesInsert400ResponseCode = "InvalidArg" + DocPagesInsert400ResponseCodeDocNotOpen DocPagesInsert400ResponseCode = "DocNotOpen" + DocPagesInsert400ResponseCodeDocOpenFailed DocPagesInsert400ResponseCode = "DocOpenFailed" + DocPagesInsert400ResponseCodeDocPasswordRequired DocPagesInsert400ResponseCode = "DocPasswordRequired" + DocPagesInsert400ResponseCodeDocPasswordIncorrect DocPagesInsert400ResponseCode = "DocPasswordIncorrect" + DocPagesInsert400ResponseCodeSharePasswordRequired DocPagesInsert400ResponseCode = "SharePasswordRequired" + DocPagesInsert400ResponseCodeAborted DocPagesInsert400ResponseCode = "Aborted" + DocPagesInsert400ResponseCodeNetwork DocPagesInsert400ResponseCode = "Network" + DocPagesInsert400ResponseCodeUnauthenticated DocPagesInsert400ResponseCode = "Unauthenticated" + DocPagesInsert400ResponseCodeForbidden DocPagesInsert400ResponseCode = "Forbidden" + DocPagesInsert400ResponseCodeNotFound DocPagesInsert400ResponseCode = "NotFound" + DocPagesInsert400ResponseCodeWireFormat DocPagesInsert400ResponseCode = "WireFormat" + DocPagesInsert400ResponseCodeRuntimeUnavailable DocPagesInsert400ResponseCode = "RuntimeUnavailable" + DocPagesInsert400ResponseCodeInvalidReference DocPagesInsert400ResponseCode = "InvalidReference" + DocPagesInsert400ResponseCodeWeakAnnotationSessionConflict DocPagesInsert400ResponseCode = "WeakAnnotationSessionConflict" + DocPagesInsert400ResponseCodeLayerVersionConflict DocPagesInsert400ResponseCode = "LayerVersionConflict" + DocPagesInsert400ResponseCodeNotImplemented DocPagesInsert400ResponseCode = "NotImplemented" + DocPagesInsert400ResponseCodeMalformedPdf DocPagesInsert400ResponseCode = "MalformedPdf" +) + +func NewDocPagesInsert400ResponseCodeFromString(s string) (DocPagesInsert400ResponseCode, error) { + switch s { + case "Unknown": + return DocPagesInsert400ResponseCodeUnknown, nil + case "InvalidArg": + return DocPagesInsert400ResponseCodeInvalidArg, nil + case "DocNotOpen": + return DocPagesInsert400ResponseCodeDocNotOpen, nil + case "DocOpenFailed": + return DocPagesInsert400ResponseCodeDocOpenFailed, nil + case "DocPasswordRequired": + return DocPagesInsert400ResponseCodeDocPasswordRequired, nil + case "DocPasswordIncorrect": + return DocPagesInsert400ResponseCodeDocPasswordIncorrect, nil + case "SharePasswordRequired": + return DocPagesInsert400ResponseCodeSharePasswordRequired, nil + case "Aborted": + return DocPagesInsert400ResponseCodeAborted, nil + case "Network": + return DocPagesInsert400ResponseCodeNetwork, nil + case "Unauthenticated": + return DocPagesInsert400ResponseCodeUnauthenticated, nil + case "Forbidden": + return DocPagesInsert400ResponseCodeForbidden, nil + case "NotFound": + return DocPagesInsert400ResponseCodeNotFound, nil + case "WireFormat": + return DocPagesInsert400ResponseCodeWireFormat, nil + case "RuntimeUnavailable": + return DocPagesInsert400ResponseCodeRuntimeUnavailable, nil + case "InvalidReference": + return DocPagesInsert400ResponseCodeInvalidReference, nil + case "WeakAnnotationSessionConflict": + return DocPagesInsert400ResponseCodeWeakAnnotationSessionConflict, nil + case "LayerVersionConflict": + return DocPagesInsert400ResponseCodeLayerVersionConflict, nil + case "NotImplemented": + return DocPagesInsert400ResponseCodeNotImplemented, nil + case "MalformedPdf": + return DocPagesInsert400ResponseCodeMalformedPdf, nil + } + var t DocPagesInsert400ResponseCode + return "", fmt.Errorf("%s is not a valid %T", s, t) +} + +func (d DocPagesInsert400ResponseCode) Ptr() *DocPagesInsert400ResponseCode { + return &d +} + +type DocPagesInsert400ResponseName string + +const ( + DocPagesInsert400ResponseNameEngineError DocPagesInsert400ResponseName = "EngineError" +) + +func NewDocPagesInsert400ResponseNameFromString(s string) (DocPagesInsert400ResponseName, error) { + switch s { + case "EngineError": + return DocPagesInsert400ResponseNameEngineError, nil + } + var t DocPagesInsert400ResponseName + return "", fmt.Errorf("%s is not a valid %T", s, t) +} + +func (d DocPagesInsert400ResponseName) Ptr() *DocPagesInsert400ResponseName { + return &d +} + +var ( + docPagesInsert404ResponseFieldName = big.NewInt(1 << 0) + docPagesInsert404ResponseFieldCode = big.NewInt(1 << 1) + docPagesInsert404ResponseFieldMessage = big.NewInt(1 << 2) + docPagesInsert404ResponseFieldDetails = big.NewInt(1 << 3) +) + +type DocPagesInsert404Response struct { + Name DocPagesInsert404ResponseName `json:"name" url:"name"` + Code DocPagesInsert404ResponseCode `json:"code" url:"code"` + Message string `json:"message" url:"message"` + Details map[string]any `json:"details,omitempty" url:"details,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 *DocPagesInsert404Response) GetName() DocPagesInsert404ResponseName { + if d == nil { + return "" + } + return d.Name +} + +func (d *DocPagesInsert404Response) GetCode() DocPagesInsert404ResponseCode { + if d == nil { + return "" + } + return d.Code +} + +func (d *DocPagesInsert404Response) GetMessage() string { + if d == nil { + return "" + } + return d.Message +} + +func (d *DocPagesInsert404Response) GetDetails() map[string]any { + if d == nil { + return nil + } + return d.Details +} + +func (d *DocPagesInsert404Response) GetExtraProperties() map[string]interface{} { + if d == nil { + return nil + } + return d.extraProperties +} + +func (d *DocPagesInsert404Response) require(field *big.Int) { + if d.explicitFields == nil { + d.explicitFields = big.NewInt(0) + } + d.explicitFields.Or(d.explicitFields, field) +} + +// SetName sets the Name field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert404Response) SetName(name DocPagesInsert404ResponseName) { + d.Name = name + d.require(docPagesInsert404ResponseFieldName) +} + +// SetCode sets the Code field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert404Response) SetCode(code DocPagesInsert404ResponseCode) { + d.Code = code + d.require(docPagesInsert404ResponseFieldCode) +} + +// SetMessage sets the Message field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert404Response) SetMessage(message string) { + d.Message = message + d.require(docPagesInsert404ResponseFieldMessage) +} + +// SetDetails sets the Details field and marks it as non-optional; +// this prevents an empty or null value for this field from being omitted during serialization. +func (d *DocPagesInsert404Response) SetDetails(details map[string]any) { + d.Details = details + d.require(docPagesInsert404ResponseFieldDetails) +} + +func (d *DocPagesInsert404Response) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsert404Response + var value unmarshaler + if err := json.Unmarshal(data, &value); err != nil { + return err + } + *d = DocPagesInsert404Response(value) + extraProperties, err := internal.ExtractExtraProperties(data, *d) + if err != nil { + return err + } + d.extraProperties = extraProperties + d.rawJSON = json.RawMessage(data) + return nil +} + +func (d *DocPagesInsert404Response) MarshalJSON() ([]byte, error) { + type embed DocPagesInsert404Response + var marshaler = struct { + embed + }{ + embed: embed(*d), + } + explicitMarshaler := internal.HandleExplicitFields(marshaler, d.explicitFields) + return json.Marshal(explicitMarshaler) +} + +func (d *DocPagesInsert404Response) String() string { + if d == nil { + return "" + } + 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 DocPagesInsert404ResponseCode string + +const ( + DocPagesInsert404ResponseCodeUnknown DocPagesInsert404ResponseCode = "Unknown" + DocPagesInsert404ResponseCodeInvalidArg DocPagesInsert404ResponseCode = "InvalidArg" + DocPagesInsert404ResponseCodeDocNotOpen DocPagesInsert404ResponseCode = "DocNotOpen" + DocPagesInsert404ResponseCodeDocOpenFailed DocPagesInsert404ResponseCode = "DocOpenFailed" + DocPagesInsert404ResponseCodeDocPasswordRequired DocPagesInsert404ResponseCode = "DocPasswordRequired" + DocPagesInsert404ResponseCodeDocPasswordIncorrect DocPagesInsert404ResponseCode = "DocPasswordIncorrect" + DocPagesInsert404ResponseCodeSharePasswordRequired DocPagesInsert404ResponseCode = "SharePasswordRequired" + DocPagesInsert404ResponseCodeAborted DocPagesInsert404ResponseCode = "Aborted" + DocPagesInsert404ResponseCodeNetwork DocPagesInsert404ResponseCode = "Network" + DocPagesInsert404ResponseCodeUnauthenticated DocPagesInsert404ResponseCode = "Unauthenticated" + DocPagesInsert404ResponseCodeForbidden DocPagesInsert404ResponseCode = "Forbidden" + DocPagesInsert404ResponseCodeNotFound DocPagesInsert404ResponseCode = "NotFound" + DocPagesInsert404ResponseCodeWireFormat DocPagesInsert404ResponseCode = "WireFormat" + DocPagesInsert404ResponseCodeRuntimeUnavailable DocPagesInsert404ResponseCode = "RuntimeUnavailable" + DocPagesInsert404ResponseCodeInvalidReference DocPagesInsert404ResponseCode = "InvalidReference" + DocPagesInsert404ResponseCodeWeakAnnotationSessionConflict DocPagesInsert404ResponseCode = "WeakAnnotationSessionConflict" + DocPagesInsert404ResponseCodeLayerVersionConflict DocPagesInsert404ResponseCode = "LayerVersionConflict" + DocPagesInsert404ResponseCodeNotImplemented DocPagesInsert404ResponseCode = "NotImplemented" + DocPagesInsert404ResponseCodeMalformedPdf DocPagesInsert404ResponseCode = "MalformedPdf" +) + +func NewDocPagesInsert404ResponseCodeFromString(s string) (DocPagesInsert404ResponseCode, error) { + switch s { + case "Unknown": + return DocPagesInsert404ResponseCodeUnknown, nil + case "InvalidArg": + return DocPagesInsert404ResponseCodeInvalidArg, nil + case "DocNotOpen": + return DocPagesInsert404ResponseCodeDocNotOpen, nil + case "DocOpenFailed": + return DocPagesInsert404ResponseCodeDocOpenFailed, nil + case "DocPasswordRequired": + return DocPagesInsert404ResponseCodeDocPasswordRequired, nil + case "DocPasswordIncorrect": + return DocPagesInsert404ResponseCodeDocPasswordIncorrect, nil + case "SharePasswordRequired": + return DocPagesInsert404ResponseCodeSharePasswordRequired, nil + case "Aborted": + return DocPagesInsert404ResponseCodeAborted, nil + case "Network": + return DocPagesInsert404ResponseCodeNetwork, nil + case "Unauthenticated": + return DocPagesInsert404ResponseCodeUnauthenticated, nil + case "Forbidden": + return DocPagesInsert404ResponseCodeForbidden, nil + case "NotFound": + return DocPagesInsert404ResponseCodeNotFound, nil + case "WireFormat": + return DocPagesInsert404ResponseCodeWireFormat, nil + case "RuntimeUnavailable": + return DocPagesInsert404ResponseCodeRuntimeUnavailable, nil + case "InvalidReference": + return DocPagesInsert404ResponseCodeInvalidReference, nil + case "WeakAnnotationSessionConflict": + return DocPagesInsert404ResponseCodeWeakAnnotationSessionConflict, nil + case "LayerVersionConflict": + return DocPagesInsert404ResponseCodeLayerVersionConflict, nil + case "NotImplemented": + return DocPagesInsert404ResponseCodeNotImplemented, nil + case "MalformedPdf": + return DocPagesInsert404ResponseCodeMalformedPdf, nil + } + var t DocPagesInsert404ResponseCode + return "", fmt.Errorf("%s is not a valid %T", s, t) +} + +func (d DocPagesInsert404ResponseCode) Ptr() *DocPagesInsert404ResponseCode { + return &d +} + +type DocPagesInsert404ResponseName string + +const ( + DocPagesInsert404ResponseNameEngineError DocPagesInsert404ResponseName = "EngineError" +) + +func NewDocPagesInsert404ResponseNameFromString(s string) (DocPagesInsert404ResponseName, error) { + switch s { + case "EngineError": + return DocPagesInsert404ResponseNameEngineError, nil + } + var t DocPagesInsert404ResponseName + return "", fmt.Errorf("%s is not a valid %T", s, t) +} + +func (d DocPagesInsert404ResponseName) Ptr() *DocPagesInsert404ResponseName { + return &d +} + +var ( + docPagesInsertBlank200ResponseFieldMeta = big.NewInt(1 << 0) +) + +type DocPagesInsertBlank200Response struct { + Meta *DocPagesInsertBlank200ResponseMeta `json:"meta" url:"meta"` // Private bitmask of fields set to an explicit value and therefore not to be omitted explicitFields *big.Int `json:"-" url:"-"` @@ -172157,21 +175529,21 @@ type DocPagesFlatten200Response struct { rawJSON json.RawMessage } -func (d *DocPagesFlatten200Response) GetMeta() *DocPagesFlatten200ResponseMeta { +func (d *DocPagesInsertBlank200Response) GetMeta() *DocPagesInsertBlank200ResponseMeta { if d == nil { return nil } return d.Meta } -func (d *DocPagesFlatten200Response) GetExtraProperties() map[string]interface{} { +func (d *DocPagesInsertBlank200Response) GetExtraProperties() map[string]interface{} { if d == nil { return nil } return d.ExtraProperties } -func (d *DocPagesFlatten200Response) require(field *big.Int) { +func (d *DocPagesInsertBlank200Response) require(field *big.Int) { if d.explicitFields == nil { d.explicitFields = big.NewInt(0) } @@ -172180,13 +175552,13 @@ func (d *DocPagesFlatten200Response) require(field *big.Int) { // SetMeta sets the Meta field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten200Response) SetMeta(meta *DocPagesFlatten200ResponseMeta) { +func (d *DocPagesInsertBlank200Response) SetMeta(meta *DocPagesInsertBlank200ResponseMeta) { d.Meta = meta - d.require(docPagesFlatten200ResponseFieldMeta) + d.require(docPagesInsertBlank200ResponseFieldMeta) } -func (d *DocPagesFlatten200Response) UnmarshalJSON(data []byte) error { - type embed DocPagesFlatten200Response +func (d *DocPagesInsertBlank200Response) UnmarshalJSON(data []byte) error { + type embed DocPagesInsertBlank200Response var unmarshaler = struct { embed }{ @@ -172195,7 +175567,7 @@ func (d *DocPagesFlatten200Response) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &unmarshaler); err != nil { return err } - *d = DocPagesFlatten200Response(unmarshaler.embed) + *d = DocPagesInsertBlank200Response(unmarshaler.embed) extraProperties, err := internal.ExtractExtraProperties(data, *d) if err != nil { return err @@ -172205,8 +175577,8 @@ func (d *DocPagesFlatten200Response) UnmarshalJSON(data []byte) error { return nil } -func (d *DocPagesFlatten200Response) MarshalJSON() ([]byte, error) { - type embed DocPagesFlatten200Response +func (d *DocPagesInsertBlank200Response) MarshalJSON() ([]byte, error) { + type embed DocPagesInsertBlank200Response var marshaler = struct { embed }{ @@ -172216,7 +175588,7 @@ func (d *DocPagesFlatten200Response) MarshalJSON() ([]byte, error) { return internal.MarshalJSONWithExtraProperties(explicitMarshaler, d.ExtraProperties) } -func (d *DocPagesFlatten200Response) String() string { +func (d *DocPagesInsertBlank200Response) String() string { if d == nil { return "" } @@ -172232,13 +175604,13 @@ func (d *DocPagesFlatten200Response) String() string { } var ( - docPagesFlatten200ResponseMetaFieldAffectedPages = big.NewInt(1 << 0) - docPagesFlatten200ResponseMetaFieldCacheDelta = big.NewInt(1 << 1) + docPagesInsertBlank200ResponseMetaFieldAffectedPages = big.NewInt(1 << 0) + docPagesInsertBlank200ResponseMetaFieldCacheDelta = big.NewInt(1 << 1) ) -type DocPagesFlatten200ResponseMeta struct { - AffectedPages []*DocPagesFlatten200ResponseMetaAffectedPagesItem `json:"affectedPages" url:"affectedPages"` - CacheDelta *DocPagesFlatten200ResponseMetaCacheDelta `json:"cacheDelta,omitempty" url:"cacheDelta,omitempty"` +type DocPagesInsertBlank200ResponseMeta struct { + AffectedPages []*DocPagesInsertBlank200ResponseMetaAffectedPagesItem `json:"affectedPages" url:"affectedPages"` + CacheDelta *DocPagesInsertBlank200ResponseMetaCacheDelta `json:"cacheDelta,omitempty" url:"cacheDelta,omitempty"` // Private bitmask of fields set to an explicit value and therefore not to be omitted explicitFields *big.Int `json:"-" url:"-"` @@ -172247,28 +175619,28 @@ type DocPagesFlatten200ResponseMeta struct { rawJSON json.RawMessage } -func (d *DocPagesFlatten200ResponseMeta) GetAffectedPages() []*DocPagesFlatten200ResponseMetaAffectedPagesItem { +func (d *DocPagesInsertBlank200ResponseMeta) GetAffectedPages() []*DocPagesInsertBlank200ResponseMetaAffectedPagesItem { if d == nil { return nil } return d.AffectedPages } -func (d *DocPagesFlatten200ResponseMeta) GetCacheDelta() *DocPagesFlatten200ResponseMetaCacheDelta { +func (d *DocPagesInsertBlank200ResponseMeta) GetCacheDelta() *DocPagesInsertBlank200ResponseMetaCacheDelta { if d == nil { return nil } return d.CacheDelta } -func (d *DocPagesFlatten200ResponseMeta) GetExtraProperties() map[string]interface{} { +func (d *DocPagesInsertBlank200ResponseMeta) GetExtraProperties() map[string]interface{} { if d == nil { return nil } return d.extraProperties } -func (d *DocPagesFlatten200ResponseMeta) require(field *big.Int) { +func (d *DocPagesInsertBlank200ResponseMeta) require(field *big.Int) { if d.explicitFields == nil { d.explicitFields = big.NewInt(0) } @@ -172277,25 +175649,25 @@ func (d *DocPagesFlatten200ResponseMeta) require(field *big.Int) { // SetAffectedPages sets the AffectedPages field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten200ResponseMeta) SetAffectedPages(affectedPages []*DocPagesFlatten200ResponseMetaAffectedPagesItem) { +func (d *DocPagesInsertBlank200ResponseMeta) SetAffectedPages(affectedPages []*DocPagesInsertBlank200ResponseMetaAffectedPagesItem) { d.AffectedPages = affectedPages - d.require(docPagesFlatten200ResponseMetaFieldAffectedPages) + d.require(docPagesInsertBlank200ResponseMetaFieldAffectedPages) } // SetCacheDelta sets the CacheDelta field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten200ResponseMeta) SetCacheDelta(cacheDelta *DocPagesFlatten200ResponseMetaCacheDelta) { +func (d *DocPagesInsertBlank200ResponseMeta) SetCacheDelta(cacheDelta *DocPagesInsertBlank200ResponseMetaCacheDelta) { d.CacheDelta = cacheDelta - d.require(docPagesFlatten200ResponseMetaFieldCacheDelta) + d.require(docPagesInsertBlank200ResponseMetaFieldCacheDelta) } -func (d *DocPagesFlatten200ResponseMeta) UnmarshalJSON(data []byte) error { - type unmarshaler DocPagesFlatten200ResponseMeta +func (d *DocPagesInsertBlank200ResponseMeta) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsertBlank200ResponseMeta var value unmarshaler if err := json.Unmarshal(data, &value); err != nil { return err } - *d = DocPagesFlatten200ResponseMeta(value) + *d = DocPagesInsertBlank200ResponseMeta(value) extraProperties, err := internal.ExtractExtraProperties(data, *d) if err != nil { return err @@ -172305,8 +175677,8 @@ func (d *DocPagesFlatten200ResponseMeta) UnmarshalJSON(data []byte) error { return nil } -func (d *DocPagesFlatten200ResponseMeta) MarshalJSON() ([]byte, error) { - type embed DocPagesFlatten200ResponseMeta +func (d *DocPagesInsertBlank200ResponseMeta) MarshalJSON() ([]byte, error) { + type embed DocPagesInsertBlank200ResponseMeta var marshaler = struct { embed }{ @@ -172316,7 +175688,7 @@ func (d *DocPagesFlatten200ResponseMeta) MarshalJSON() ([]byte, error) { return json.Marshal(explicitMarshaler) } -func (d *DocPagesFlatten200ResponseMeta) String() string { +func (d *DocPagesInsertBlank200ResponseMeta) String() string { if d == nil { return "" } @@ -172332,15 +175704,15 @@ func (d *DocPagesFlatten200ResponseMeta) String() string { } var ( - docPagesFlatten200ResponseMetaAffectedPagesItemFieldPageObjectNumber = big.NewInt(1 << 0) - docPagesFlatten200ResponseMetaAffectedPagesItemFieldRevision = big.NewInt(1 << 1) - docPagesFlatten200ResponseMetaAffectedPagesItemFieldWeakAnnotationState = big.NewInt(1 << 2) + docPagesInsertBlank200ResponseMetaAffectedPagesItemFieldPageObjectNumber = big.NewInt(1 << 0) + docPagesInsertBlank200ResponseMetaAffectedPagesItemFieldRevision = big.NewInt(1 << 1) + docPagesInsertBlank200ResponseMetaAffectedPagesItemFieldWeakAnnotationState = big.NewInt(1 << 2) ) -type DocPagesFlatten200ResponseMetaAffectedPagesItem struct { - PageObjectNumber int `json:"pageObjectNumber" url:"pageObjectNumber"` - Revision *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision `json:"revision" url:"revision"` - WeakAnnotationState *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState `json:"weakAnnotationState" url:"weakAnnotationState"` +type DocPagesInsertBlank200ResponseMetaAffectedPagesItem struct { + PageObjectNumber int `json:"pageObjectNumber" url:"pageObjectNumber"` + Revision *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision `json:"revision" url:"revision"` + WeakAnnotationState *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState `json:"weakAnnotationState" url:"weakAnnotationState"` // Private bitmask of fields set to an explicit value and therefore not to be omitted explicitFields *big.Int `json:"-" url:"-"` @@ -172349,35 +175721,35 @@ type DocPagesFlatten200ResponseMetaAffectedPagesItem struct { rawJSON json.RawMessage } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) GetPageObjectNumber() int { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItem) GetPageObjectNumber() int { if d == nil { return 0 } return d.PageObjectNumber } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) GetRevision() *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItem) GetRevision() *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision { if d == nil { return nil } return d.Revision } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) GetWeakAnnotationState() *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItem) GetWeakAnnotationState() *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState { if d == nil { return nil } return d.WeakAnnotationState } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) GetExtraProperties() map[string]interface{} { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItem) GetExtraProperties() map[string]interface{} { if d == nil { return nil } return d.extraProperties } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) require(field *big.Int) { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItem) require(field *big.Int) { if d.explicitFields == nil { d.explicitFields = big.NewInt(0) } @@ -172386,32 +175758,32 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) require(field *big.Int // SetPageObjectNumber sets the PageObjectNumber field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) SetPageObjectNumber(pageObjectNumber int) { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItem) SetPageObjectNumber(pageObjectNumber int) { d.PageObjectNumber = pageObjectNumber - d.require(docPagesFlatten200ResponseMetaAffectedPagesItemFieldPageObjectNumber) + d.require(docPagesInsertBlank200ResponseMetaAffectedPagesItemFieldPageObjectNumber) } // 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 *DocPagesFlatten200ResponseMetaAffectedPagesItem) SetRevision(revision *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItem) SetRevision(revision *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision) { d.Revision = revision - d.require(docPagesFlatten200ResponseMetaAffectedPagesItemFieldRevision) + d.require(docPagesInsertBlank200ResponseMetaAffectedPagesItemFieldRevision) } // SetWeakAnnotationState sets the WeakAnnotationState field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) SetWeakAnnotationState(weakAnnotationState *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItem) SetWeakAnnotationState(weakAnnotationState *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState) { d.WeakAnnotationState = weakAnnotationState - d.require(docPagesFlatten200ResponseMetaAffectedPagesItemFieldWeakAnnotationState) + d.require(docPagesInsertBlank200ResponseMetaAffectedPagesItemFieldWeakAnnotationState) } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) UnmarshalJSON(data []byte) error { - type unmarshaler DocPagesFlatten200ResponseMetaAffectedPagesItem +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItem) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsertBlank200ResponseMetaAffectedPagesItem var value unmarshaler if err := json.Unmarshal(data, &value); err != nil { return err } - *d = DocPagesFlatten200ResponseMetaAffectedPagesItem(value) + *d = DocPagesInsertBlank200ResponseMetaAffectedPagesItem(value) extraProperties, err := internal.ExtractExtraProperties(data, *d) if err != nil { return err @@ -172421,8 +175793,8 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) UnmarshalJSON(data []b return nil } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) MarshalJSON() ([]byte, error) { - type embed DocPagesFlatten200ResponseMetaAffectedPagesItem +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItem) MarshalJSON() ([]byte, error) { + type embed DocPagesInsertBlank200ResponseMetaAffectedPagesItem var marshaler = struct { embed }{ @@ -172432,7 +175804,7 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) MarshalJSON() ([]byte, return json.Marshal(explicitMarshaler) } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) String() string { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItem) String() string { if d == nil { return "" } @@ -172448,12 +175820,12 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItem) String() string { } var ( - docPagesFlatten200ResponseMetaAffectedPagesItemRevisionFieldDocSessionID = big.NewInt(1 << 0) - docPagesFlatten200ResponseMetaAffectedPagesItemRevisionFieldPageObjectNumber = big.NewInt(1 << 1) - docPagesFlatten200ResponseMetaAffectedPagesItemRevisionFieldGeneration = big.NewInt(1 << 2) + docPagesInsertBlank200ResponseMetaAffectedPagesItemRevisionFieldDocSessionID = big.NewInt(1 << 0) + docPagesInsertBlank200ResponseMetaAffectedPagesItemRevisionFieldPageObjectNumber = big.NewInt(1 << 1) + docPagesInsertBlank200ResponseMetaAffectedPagesItemRevisionFieldGeneration = big.NewInt(1 << 2) ) -type DocPagesFlatten200ResponseMetaAffectedPagesItemRevision struct { +type DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision struct { DocSessionID string `json:"docSessionId" url:"docSessionId"` PageObjectNumber int `json:"pageObjectNumber" url:"pageObjectNumber"` Generation int `json:"generation" url:"generation"` @@ -172465,35 +175837,35 @@ type DocPagesFlatten200ResponseMetaAffectedPagesItemRevision struct { rawJSON json.RawMessage } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) GetDocSessionID() string { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision) GetDocSessionID() string { if d == nil { return "" } return d.DocSessionID } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) GetPageObjectNumber() int { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision) GetPageObjectNumber() int { if d == nil { return 0 } return d.PageObjectNumber } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) GetGeneration() int { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision) GetGeneration() int { if d == nil { return 0 } return d.Generation } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) GetExtraProperties() map[string]interface{} { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision) GetExtraProperties() map[string]interface{} { if d == nil { return nil } return d.extraProperties } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) require(field *big.Int) { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision) require(field *big.Int) { if d.explicitFields == nil { d.explicitFields = big.NewInt(0) } @@ -172502,32 +175874,32 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) require(field // SetDocSessionID sets the DocSessionID field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) SetDocSessionID(docSessionID string) { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision) SetDocSessionID(docSessionID string) { d.DocSessionID = docSessionID - d.require(docPagesFlatten200ResponseMetaAffectedPagesItemRevisionFieldDocSessionID) + d.require(docPagesInsertBlank200ResponseMetaAffectedPagesItemRevisionFieldDocSessionID) } // SetPageObjectNumber sets the PageObjectNumber field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) SetPageObjectNumber(pageObjectNumber int) { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision) SetPageObjectNumber(pageObjectNumber int) { d.PageObjectNumber = pageObjectNumber - d.require(docPagesFlatten200ResponseMetaAffectedPagesItemRevisionFieldPageObjectNumber) + d.require(docPagesInsertBlank200ResponseMetaAffectedPagesItemRevisionFieldPageObjectNumber) } // SetGeneration sets the Generation field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) SetGeneration(generation int) { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision) SetGeneration(generation int) { d.Generation = generation - d.require(docPagesFlatten200ResponseMetaAffectedPagesItemRevisionFieldGeneration) + d.require(docPagesInsertBlank200ResponseMetaAffectedPagesItemRevisionFieldGeneration) } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) UnmarshalJSON(data []byte) error { - type unmarshaler DocPagesFlatten200ResponseMetaAffectedPagesItemRevision +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision var value unmarshaler if err := json.Unmarshal(data, &value); err != nil { return err } - *d = DocPagesFlatten200ResponseMetaAffectedPagesItemRevision(value) + *d = DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision(value) extraProperties, err := internal.ExtractExtraProperties(data, *d) if err != nil { return err @@ -172537,8 +175909,8 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) UnmarshalJSON( return nil } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) MarshalJSON() ([]byte, error) { - type embed DocPagesFlatten200ResponseMetaAffectedPagesItemRevision +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision) MarshalJSON() ([]byte, error) { + type embed DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision var marshaler = struct { embed }{ @@ -172548,7 +175920,7 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) MarshalJSON() return json.Marshal(explicitMarshaler) } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) String() string { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision) String() string { if d == nil { return "" } @@ -172563,36 +175935,36 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemRevision) String() strin return fmt.Sprintf("%#v", d) } -type DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState struct { +type DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState struct { Kind string - Unknown *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown - Known *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + Unknown *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + Known *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown rawJSON json.RawMessage } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) GetKind() string { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState) GetKind() string { if d == nil { return "" } return d.Kind } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) GetUnknown() *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState) GetUnknown() *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown { if d == nil { return nil } return d.Unknown } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) GetKnown() *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState) GetKnown() *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown { if d == nil { return nil } return d.Known } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) UnmarshalJSON(data []byte) error { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState) UnmarshalJSON(data []byte) error { var unmarshaler struct { Kind string `json:"kind"` } @@ -172605,13 +175977,13 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) Unm } switch unmarshaler.Kind { case "unknown": - value := new(DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) + value := new(DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) if err := json.Unmarshal(data, &value); err != nil { return err } d.Unknown = value case "known": - value := new(DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) + value := new(DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) if err := json.Unmarshal(data, &value); err != nil { return err } @@ -172621,7 +175993,7 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) Unm return nil } -func (d DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) MarshalJSON() ([]byte, error) { +func (d DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState) MarshalJSON() ([]byte, error) { if err := d.validate(); err != nil { return nil, err } @@ -172637,12 +176009,12 @@ func (d DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) Mars return nil, fmt.Errorf("type %T does not define a non-empty union type", d) } -type DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateVisitor interface { - VisitUnknown(*DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) error - VisitKnown(*DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) error +type DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateVisitor interface { + VisitUnknown(*DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) error + VisitKnown(*DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) error } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) Accept(visitor DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateVisitor) error { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState) Accept(visitor DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateVisitor) error { if d.Unknown != nil { return visitor.VisitUnknown(d.Unknown) } @@ -172652,7 +176024,7 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) Acc return fmt.Errorf("type %T does not define a non-empty union type", d) } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) validate() error { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState) validate() error { if d == nil { return fmt.Errorf("type %T is nil", d) } @@ -172690,10 +176062,10 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationState) val } var ( - docPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnownFieldHasAnyWeakAnnotations = big.NewInt(1 << 0) + docPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnownFieldHasAnyWeakAnnotations = big.NewInt(1 << 0) ) -type DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown struct { +type DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown struct { HasAnyWeakAnnotations bool `json:"hasAnyWeakAnnotations" url:"hasAnyWeakAnnotations"` // Private bitmask of fields set to an explicit value and therefore not to be omitted @@ -172703,21 +176075,21 @@ type DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown str rawJSON json.RawMessage } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) GetHasAnyWeakAnnotations() bool { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) GetHasAnyWeakAnnotations() bool { if d == nil { return false } return d.HasAnyWeakAnnotations } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) GetExtraProperties() map[string]interface{} { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) GetExtraProperties() map[string]interface{} { if d == nil { return nil } return d.extraProperties } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) require(field *big.Int) { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) require(field *big.Int) { if d.explicitFields == nil { d.explicitFields = big.NewInt(0) } @@ -172726,18 +176098,18 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown // SetHasAnyWeakAnnotations sets the HasAnyWeakAnnotations field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) SetHasAnyWeakAnnotations(hasAnyWeakAnnotations bool) { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) SetHasAnyWeakAnnotations(hasAnyWeakAnnotations bool) { d.HasAnyWeakAnnotations = hasAnyWeakAnnotations - d.require(docPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnownFieldHasAnyWeakAnnotations) + d.require(docPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnownFieldHasAnyWeakAnnotations) } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) UnmarshalJSON(data []byte) error { - type unmarshaler DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown var value unmarshaler if err := json.Unmarshal(data, &value); err != nil { return err } - *d = DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(value) + *d = DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(value) extraProperties, err := internal.ExtractExtraProperties(data, *d) if err != nil { return err @@ -172747,8 +176119,8 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown return nil } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) MarshalJSON() ([]byte, error) { - type embed DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) MarshalJSON() ([]byte, error) { + type embed DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown var marshaler = struct { embed }{ @@ -172758,7 +176130,7 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown return json.Marshal(explicitMarshaler) } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) String() string { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown) String() string { if d == nil { return "" } @@ -172773,7 +176145,7 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown return fmt.Sprintf("%#v", d) } -type DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown struct { +type DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown struct { // Private bitmask of fields set to an explicit value and therefore not to be omitted explicitFields *big.Int `json:"-" url:"-"` @@ -172782,27 +176154,27 @@ type DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown s rawJSON json.RawMessage } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) GetExtraProperties() map[string]interface{} { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) GetExtraProperties() map[string]interface{} { if d == nil { return nil } return d.extraProperties } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) require(field *big.Int) { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) require(field *big.Int) { if d.explicitFields == nil { d.explicitFields = big.NewInt(0) } d.explicitFields.Or(d.explicitFields, field) } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) UnmarshalJSON(data []byte) error { - type unmarshaler DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown var value unmarshaler if err := json.Unmarshal(data, &value); err != nil { return err } - *d = DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown(value) + *d = DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown(value) extraProperties, err := internal.ExtractExtraProperties(data, *d) if err != nil { return err @@ -172812,8 +176184,8 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnkno return nil } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) MarshalJSON() ([]byte, error) { - type embed DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) MarshalJSON() ([]byte, error) { + type embed DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown var marshaler = struct { embed }{ @@ -172823,7 +176195,7 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnkno return json.Marshal(explicitMarshaler) } -func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) String() string { +func (d *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown) String() string { if d == nil { return "" } @@ -172839,15 +176211,15 @@ func (d *DocPagesFlatten200ResponseMetaAffectedPagesItemWeakAnnotationStateUnkno } var ( - docPagesFlatten200ResponseMetaCacheDeltaFieldPreviousDocVersion = big.NewInt(1 << 0) - docPagesFlatten200ResponseMetaCacheDeltaFieldDocVersion = big.NewInt(1 << 1) - docPagesFlatten200ResponseMetaCacheDeltaFieldPages = big.NewInt(1 << 2) + docPagesInsertBlank200ResponseMetaCacheDeltaFieldPreviousDocVersion = big.NewInt(1 << 0) + docPagesInsertBlank200ResponseMetaCacheDeltaFieldDocVersion = big.NewInt(1 << 1) + docPagesInsertBlank200ResponseMetaCacheDeltaFieldPages = big.NewInt(1 << 2) ) -type DocPagesFlatten200ResponseMetaCacheDelta struct { - PreviousDocVersion int `json:"previousDocVersion" url:"previousDocVersion"` - DocVersion int `json:"docVersion" url:"docVersion"` - Pages []*DocPagesFlatten200ResponseMetaCacheDeltaPagesItem `json:"pages" url:"pages"` +type DocPagesInsertBlank200ResponseMetaCacheDelta struct { + PreviousDocVersion int `json:"previousDocVersion" url:"previousDocVersion"` + DocVersion int `json:"docVersion" url:"docVersion"` + Pages []*DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem `json:"pages" url:"pages"` // Private bitmask of fields set to an explicit value and therefore not to be omitted explicitFields *big.Int `json:"-" url:"-"` @@ -172856,35 +176228,35 @@ type DocPagesFlatten200ResponseMetaCacheDelta struct { rawJSON json.RawMessage } -func (d *DocPagesFlatten200ResponseMetaCacheDelta) GetPreviousDocVersion() int { +func (d *DocPagesInsertBlank200ResponseMetaCacheDelta) GetPreviousDocVersion() int { if d == nil { return 0 } return d.PreviousDocVersion } -func (d *DocPagesFlatten200ResponseMetaCacheDelta) GetDocVersion() int { +func (d *DocPagesInsertBlank200ResponseMetaCacheDelta) GetDocVersion() int { if d == nil { return 0 } return d.DocVersion } -func (d *DocPagesFlatten200ResponseMetaCacheDelta) GetPages() []*DocPagesFlatten200ResponseMetaCacheDeltaPagesItem { +func (d *DocPagesInsertBlank200ResponseMetaCacheDelta) GetPages() []*DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem { if d == nil { return nil } return d.Pages } -func (d *DocPagesFlatten200ResponseMetaCacheDelta) GetExtraProperties() map[string]interface{} { +func (d *DocPagesInsertBlank200ResponseMetaCacheDelta) GetExtraProperties() map[string]interface{} { if d == nil { return nil } return d.extraProperties } -func (d *DocPagesFlatten200ResponseMetaCacheDelta) require(field *big.Int) { +func (d *DocPagesInsertBlank200ResponseMetaCacheDelta) require(field *big.Int) { if d.explicitFields == nil { d.explicitFields = big.NewInt(0) } @@ -172893,32 +176265,32 @@ func (d *DocPagesFlatten200ResponseMetaCacheDelta) require(field *big.Int) { // SetPreviousDocVersion sets the PreviousDocVersion field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten200ResponseMetaCacheDelta) SetPreviousDocVersion(previousDocVersion int) { +func (d *DocPagesInsertBlank200ResponseMetaCacheDelta) SetPreviousDocVersion(previousDocVersion int) { d.PreviousDocVersion = previousDocVersion - d.require(docPagesFlatten200ResponseMetaCacheDeltaFieldPreviousDocVersion) + d.require(docPagesInsertBlank200ResponseMetaCacheDeltaFieldPreviousDocVersion) } // SetDocVersion sets the DocVersion field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten200ResponseMetaCacheDelta) SetDocVersion(docVersion int) { +func (d *DocPagesInsertBlank200ResponseMetaCacheDelta) SetDocVersion(docVersion int) { d.DocVersion = docVersion - d.require(docPagesFlatten200ResponseMetaCacheDeltaFieldDocVersion) + d.require(docPagesInsertBlank200ResponseMetaCacheDeltaFieldDocVersion) } // SetPages sets the Pages field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten200ResponseMetaCacheDelta) SetPages(pages []*DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) { +func (d *DocPagesInsertBlank200ResponseMetaCacheDelta) SetPages(pages []*DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem) { d.Pages = pages - d.require(docPagesFlatten200ResponseMetaCacheDeltaFieldPages) + d.require(docPagesInsertBlank200ResponseMetaCacheDeltaFieldPages) } -func (d *DocPagesFlatten200ResponseMetaCacheDelta) UnmarshalJSON(data []byte) error { - type unmarshaler DocPagesFlatten200ResponseMetaCacheDelta +func (d *DocPagesInsertBlank200ResponseMetaCacheDelta) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsertBlank200ResponseMetaCacheDelta var value unmarshaler if err := json.Unmarshal(data, &value); err != nil { return err } - *d = DocPagesFlatten200ResponseMetaCacheDelta(value) + *d = DocPagesInsertBlank200ResponseMetaCacheDelta(value) extraProperties, err := internal.ExtractExtraProperties(data, *d) if err != nil { return err @@ -172928,8 +176300,8 @@ func (d *DocPagesFlatten200ResponseMetaCacheDelta) UnmarshalJSON(data []byte) er return nil } -func (d *DocPagesFlatten200ResponseMetaCacheDelta) MarshalJSON() ([]byte, error) { - type embed DocPagesFlatten200ResponseMetaCacheDelta +func (d *DocPagesInsertBlank200ResponseMetaCacheDelta) MarshalJSON() ([]byte, error) { + type embed DocPagesInsertBlank200ResponseMetaCacheDelta var marshaler = struct { embed }{ @@ -172939,7 +176311,7 @@ func (d *DocPagesFlatten200ResponseMetaCacheDelta) MarshalJSON() ([]byte, error) return json.Marshal(explicitMarshaler) } -func (d *DocPagesFlatten200ResponseMetaCacheDelta) String() string { +func (d *DocPagesInsertBlank200ResponseMetaCacheDelta) String() string { if d == nil { return "" } @@ -172955,13 +176327,13 @@ func (d *DocPagesFlatten200ResponseMetaCacheDelta) String() string { } var ( - docPagesFlatten200ResponseMetaCacheDeltaPagesItemFieldPageObjectNumber = big.NewInt(1 << 0) - docPagesFlatten200ResponseMetaCacheDeltaPagesItemFieldCache = big.NewInt(1 << 1) + docPagesInsertBlank200ResponseMetaCacheDeltaPagesItemFieldPageObjectNumber = big.NewInt(1 << 0) + docPagesInsertBlank200ResponseMetaCacheDeltaPagesItemFieldCache = big.NewInt(1 << 1) ) -type DocPagesFlatten200ResponseMetaCacheDeltaPagesItem struct { - PageObjectNumber int `json:"pageObjectNumber" url:"pageObjectNumber"` - Cache *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache `json:"cache" url:"cache"` +type DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem struct { + PageObjectNumber int `json:"pageObjectNumber" url:"pageObjectNumber"` + Cache *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache `json:"cache" url:"cache"` // Private bitmask of fields set to an explicit value and therefore not to be omitted explicitFields *big.Int `json:"-" url:"-"` @@ -172970,28 +176342,28 @@ type DocPagesFlatten200ResponseMetaCacheDeltaPagesItem struct { rawJSON json.RawMessage } -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) GetPageObjectNumber() int { +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem) GetPageObjectNumber() int { if d == nil { return 0 } return d.PageObjectNumber } -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) GetCache() *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache { +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem) GetCache() *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache { if d == nil { return nil } return d.Cache } -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) GetExtraProperties() map[string]interface{} { +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem) GetExtraProperties() map[string]interface{} { if d == nil { return nil } return d.extraProperties } -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) require(field *big.Int) { +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem) require(field *big.Int) { if d.explicitFields == nil { d.explicitFields = big.NewInt(0) } @@ -173000,25 +176372,25 @@ func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) require(field *big.I // SetPageObjectNumber sets the PageObjectNumber field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) SetPageObjectNumber(pageObjectNumber int) { +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem) SetPageObjectNumber(pageObjectNumber int) { d.PageObjectNumber = pageObjectNumber - d.require(docPagesFlatten200ResponseMetaCacheDeltaPagesItemFieldPageObjectNumber) + d.require(docPagesInsertBlank200ResponseMetaCacheDeltaPagesItemFieldPageObjectNumber) } // SetCache sets the Cache field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) SetCache(cache *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) { +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem) SetCache(cache *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache) { d.Cache = cache - d.require(docPagesFlatten200ResponseMetaCacheDeltaPagesItemFieldCache) + d.require(docPagesInsertBlank200ResponseMetaCacheDeltaPagesItemFieldCache) } -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) UnmarshalJSON(data []byte) error { - type unmarshaler DocPagesFlatten200ResponseMetaCacheDeltaPagesItem +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem var value unmarshaler if err := json.Unmarshal(data, &value); err != nil { return err } - *d = DocPagesFlatten200ResponseMetaCacheDeltaPagesItem(value) + *d = DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem(value) extraProperties, err := internal.ExtractExtraProperties(data, *d) if err != nil { return err @@ -173028,8 +176400,8 @@ func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) UnmarshalJSON(data [ return nil } -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) MarshalJSON() ([]byte, error) { - type embed DocPagesFlatten200ResponseMetaCacheDeltaPagesItem +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem) MarshalJSON() ([]byte, error) { + type embed DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem var marshaler = struct { embed }{ @@ -173039,7 +176411,7 @@ func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) MarshalJSON() ([]byt return json.Marshal(explicitMarshaler) } -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) String() string { +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem) String() string { if d == nil { return "" } @@ -173055,11 +176427,11 @@ func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItem) String() string { } var ( - docPagesFlatten200ResponseMetaCacheDeltaPagesItemCacheFieldContentVersion = big.NewInt(1 << 0) - docPagesFlatten200ResponseMetaCacheDeltaPagesItemCacheFieldAnnotationVersion = big.NewInt(1 << 1) + docPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCacheFieldContentVersion = big.NewInt(1 << 0) + docPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCacheFieldAnnotationVersion = big.NewInt(1 << 1) ) -type DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache struct { +type DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache struct { ContentVersion int `json:"contentVersion" url:"contentVersion"` AnnotationVersion int `json:"annotationVersion" url:"annotationVersion"` @@ -173070,28 +176442,28 @@ type DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache struct { rawJSON json.RawMessage } -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) GetContentVersion() int { +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache) GetContentVersion() int { if d == nil { return 0 } return d.ContentVersion } -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) GetAnnotationVersion() int { +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache) GetAnnotationVersion() int { if d == nil { return 0 } return d.AnnotationVersion } -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) GetExtraProperties() map[string]interface{} { +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache) GetExtraProperties() map[string]interface{} { if d == nil { return nil } return d.extraProperties } -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) require(field *big.Int) { +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache) require(field *big.Int) { if d.explicitFields == nil { d.explicitFields = big.NewInt(0) } @@ -173100,25 +176472,25 @@ func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) require(field * // SetContentVersion sets the ContentVersion field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) SetContentVersion(contentVersion int) { +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache) SetContentVersion(contentVersion int) { d.ContentVersion = contentVersion - d.require(docPagesFlatten200ResponseMetaCacheDeltaPagesItemCacheFieldContentVersion) + d.require(docPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCacheFieldContentVersion) } // SetAnnotationVersion sets the AnnotationVersion field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) SetAnnotationVersion(annotationVersion int) { +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache) SetAnnotationVersion(annotationVersion int) { d.AnnotationVersion = annotationVersion - d.require(docPagesFlatten200ResponseMetaCacheDeltaPagesItemCacheFieldAnnotationVersion) + d.require(docPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCacheFieldAnnotationVersion) } -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) UnmarshalJSON(data []byte) error { - type unmarshaler DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache var value unmarshaler if err := json.Unmarshal(data, &value); err != nil { return err } - *d = DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache(value) + *d = DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache(value) extraProperties, err := internal.ExtractExtraProperties(data, *d) if err != nil { return err @@ -173128,8 +176500,8 @@ func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) UnmarshalJSON(d return nil } -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) MarshalJSON() ([]byte, error) { - type embed DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache) MarshalJSON() ([]byte, error) { + type embed DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache var marshaler = struct { embed }{ @@ -173139,7 +176511,7 @@ func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) MarshalJSON() ( return json.Marshal(explicitMarshaler) } -func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) String() string { +func (d *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache) String() string { if d == nil { return "" } @@ -173155,17 +176527,17 @@ func (d *DocPagesFlatten200ResponseMetaCacheDeltaPagesItemCache) String() string } var ( - docPagesFlatten400ResponseFieldName = big.NewInt(1 << 0) - docPagesFlatten400ResponseFieldCode = big.NewInt(1 << 1) - docPagesFlatten400ResponseFieldMessage = big.NewInt(1 << 2) - docPagesFlatten400ResponseFieldDetails = big.NewInt(1 << 3) + docPagesInsertBlank400ResponseFieldName = big.NewInt(1 << 0) + docPagesInsertBlank400ResponseFieldCode = big.NewInt(1 << 1) + docPagesInsertBlank400ResponseFieldMessage = big.NewInt(1 << 2) + docPagesInsertBlank400ResponseFieldDetails = big.NewInt(1 << 3) ) -type DocPagesFlatten400Response struct { - Name DocPagesFlatten400ResponseName `json:"name" url:"name"` - Code DocPagesFlatten400ResponseCode `json:"code" url:"code"` - Message string `json:"message" url:"message"` - Details map[string]any `json:"details,omitempty" url:"details,omitempty"` +type DocPagesInsertBlank400Response struct { + Name DocPagesInsertBlank400ResponseName `json:"name" url:"name"` + Code DocPagesInsertBlank400ResponseCode `json:"code" url:"code"` + Message string `json:"message" url:"message"` + Details map[string]any `json:"details,omitempty" url:"details,omitempty"` // Private bitmask of fields set to an explicit value and therefore not to be omitted explicitFields *big.Int `json:"-" url:"-"` @@ -173174,42 +176546,42 @@ type DocPagesFlatten400Response struct { rawJSON json.RawMessage } -func (d *DocPagesFlatten400Response) GetName() DocPagesFlatten400ResponseName { +func (d *DocPagesInsertBlank400Response) GetName() DocPagesInsertBlank400ResponseName { if d == nil { return "" } return d.Name } -func (d *DocPagesFlatten400Response) GetCode() DocPagesFlatten400ResponseCode { +func (d *DocPagesInsertBlank400Response) GetCode() DocPagesInsertBlank400ResponseCode { if d == nil { return "" } return d.Code } -func (d *DocPagesFlatten400Response) GetMessage() string { +func (d *DocPagesInsertBlank400Response) GetMessage() string { if d == nil { return "" } return d.Message } -func (d *DocPagesFlatten400Response) GetDetails() map[string]any { +func (d *DocPagesInsertBlank400Response) GetDetails() map[string]any { if d == nil { return nil } return d.Details } -func (d *DocPagesFlatten400Response) GetExtraProperties() map[string]interface{} { +func (d *DocPagesInsertBlank400Response) GetExtraProperties() map[string]interface{} { if d == nil { return nil } return d.extraProperties } -func (d *DocPagesFlatten400Response) require(field *big.Int) { +func (d *DocPagesInsertBlank400Response) require(field *big.Int) { if d.explicitFields == nil { d.explicitFields = big.NewInt(0) } @@ -173218,39 +176590,39 @@ func (d *DocPagesFlatten400Response) require(field *big.Int) { // SetName sets the Name field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten400Response) SetName(name DocPagesFlatten400ResponseName) { +func (d *DocPagesInsertBlank400Response) SetName(name DocPagesInsertBlank400ResponseName) { d.Name = name - d.require(docPagesFlatten400ResponseFieldName) + d.require(docPagesInsertBlank400ResponseFieldName) } // SetCode sets the Code field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten400Response) SetCode(code DocPagesFlatten400ResponseCode) { +func (d *DocPagesInsertBlank400Response) SetCode(code DocPagesInsertBlank400ResponseCode) { d.Code = code - d.require(docPagesFlatten400ResponseFieldCode) + d.require(docPagesInsertBlank400ResponseFieldCode) } // SetMessage sets the Message field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten400Response) SetMessage(message string) { +func (d *DocPagesInsertBlank400Response) SetMessage(message string) { d.Message = message - d.require(docPagesFlatten400ResponseFieldMessage) + d.require(docPagesInsertBlank400ResponseFieldMessage) } // SetDetails sets the Details field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten400Response) SetDetails(details map[string]any) { +func (d *DocPagesInsertBlank400Response) SetDetails(details map[string]any) { d.Details = details - d.require(docPagesFlatten400ResponseFieldDetails) + d.require(docPagesInsertBlank400ResponseFieldDetails) } -func (d *DocPagesFlatten400Response) UnmarshalJSON(data []byte) error { - type unmarshaler DocPagesFlatten400Response +func (d *DocPagesInsertBlank400Response) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsertBlank400Response var value unmarshaler if err := json.Unmarshal(data, &value); err != nil { return err } - *d = DocPagesFlatten400Response(value) + *d = DocPagesInsertBlank400Response(value) extraProperties, err := internal.ExtractExtraProperties(data, *d) if err != nil { return err @@ -173260,8 +176632,8 @@ func (d *DocPagesFlatten400Response) UnmarshalJSON(data []byte) error { return nil } -func (d *DocPagesFlatten400Response) MarshalJSON() ([]byte, error) { - type embed DocPagesFlatten400Response +func (d *DocPagesInsertBlank400Response) MarshalJSON() ([]byte, error) { + type embed DocPagesInsertBlank400Response var marshaler = struct { embed }{ @@ -173271,7 +176643,7 @@ func (d *DocPagesFlatten400Response) MarshalJSON() ([]byte, error) { return json.Marshal(explicitMarshaler) } -func (d *DocPagesFlatten400Response) String() string { +func (d *DocPagesInsertBlank400Response) String() string { if d == nil { return "" } @@ -173286,110 +176658,110 @@ func (d *DocPagesFlatten400Response) String() string { return fmt.Sprintf("%#v", d) } -type DocPagesFlatten400ResponseCode string +type DocPagesInsertBlank400ResponseCode string const ( - DocPagesFlatten400ResponseCodeUnknown DocPagesFlatten400ResponseCode = "Unknown" - DocPagesFlatten400ResponseCodeInvalidArg DocPagesFlatten400ResponseCode = "InvalidArg" - DocPagesFlatten400ResponseCodeDocNotOpen DocPagesFlatten400ResponseCode = "DocNotOpen" - DocPagesFlatten400ResponseCodeDocOpenFailed DocPagesFlatten400ResponseCode = "DocOpenFailed" - DocPagesFlatten400ResponseCodeDocPasswordRequired DocPagesFlatten400ResponseCode = "DocPasswordRequired" - DocPagesFlatten400ResponseCodeDocPasswordIncorrect DocPagesFlatten400ResponseCode = "DocPasswordIncorrect" - DocPagesFlatten400ResponseCodeSharePasswordRequired DocPagesFlatten400ResponseCode = "SharePasswordRequired" - DocPagesFlatten400ResponseCodeAborted DocPagesFlatten400ResponseCode = "Aborted" - DocPagesFlatten400ResponseCodeNetwork DocPagesFlatten400ResponseCode = "Network" - DocPagesFlatten400ResponseCodeUnauthenticated DocPagesFlatten400ResponseCode = "Unauthenticated" - DocPagesFlatten400ResponseCodeForbidden DocPagesFlatten400ResponseCode = "Forbidden" - DocPagesFlatten400ResponseCodeNotFound DocPagesFlatten400ResponseCode = "NotFound" - DocPagesFlatten400ResponseCodeWireFormat DocPagesFlatten400ResponseCode = "WireFormat" - DocPagesFlatten400ResponseCodeRuntimeUnavailable DocPagesFlatten400ResponseCode = "RuntimeUnavailable" - DocPagesFlatten400ResponseCodeInvalidReference DocPagesFlatten400ResponseCode = "InvalidReference" - DocPagesFlatten400ResponseCodeWeakAnnotationSessionConflict DocPagesFlatten400ResponseCode = "WeakAnnotationSessionConflict" - DocPagesFlatten400ResponseCodeLayerVersionConflict DocPagesFlatten400ResponseCode = "LayerVersionConflict" - DocPagesFlatten400ResponseCodeNotImplemented DocPagesFlatten400ResponseCode = "NotImplemented" - DocPagesFlatten400ResponseCodeMalformedPdf DocPagesFlatten400ResponseCode = "MalformedPdf" + DocPagesInsertBlank400ResponseCodeUnknown DocPagesInsertBlank400ResponseCode = "Unknown" + DocPagesInsertBlank400ResponseCodeInvalidArg DocPagesInsertBlank400ResponseCode = "InvalidArg" + DocPagesInsertBlank400ResponseCodeDocNotOpen DocPagesInsertBlank400ResponseCode = "DocNotOpen" + DocPagesInsertBlank400ResponseCodeDocOpenFailed DocPagesInsertBlank400ResponseCode = "DocOpenFailed" + DocPagesInsertBlank400ResponseCodeDocPasswordRequired DocPagesInsertBlank400ResponseCode = "DocPasswordRequired" + DocPagesInsertBlank400ResponseCodeDocPasswordIncorrect DocPagesInsertBlank400ResponseCode = "DocPasswordIncorrect" + DocPagesInsertBlank400ResponseCodeSharePasswordRequired DocPagesInsertBlank400ResponseCode = "SharePasswordRequired" + DocPagesInsertBlank400ResponseCodeAborted DocPagesInsertBlank400ResponseCode = "Aborted" + DocPagesInsertBlank400ResponseCodeNetwork DocPagesInsertBlank400ResponseCode = "Network" + DocPagesInsertBlank400ResponseCodeUnauthenticated DocPagesInsertBlank400ResponseCode = "Unauthenticated" + DocPagesInsertBlank400ResponseCodeForbidden DocPagesInsertBlank400ResponseCode = "Forbidden" + DocPagesInsertBlank400ResponseCodeNotFound DocPagesInsertBlank400ResponseCode = "NotFound" + DocPagesInsertBlank400ResponseCodeWireFormat DocPagesInsertBlank400ResponseCode = "WireFormat" + DocPagesInsertBlank400ResponseCodeRuntimeUnavailable DocPagesInsertBlank400ResponseCode = "RuntimeUnavailable" + DocPagesInsertBlank400ResponseCodeInvalidReference DocPagesInsertBlank400ResponseCode = "InvalidReference" + DocPagesInsertBlank400ResponseCodeWeakAnnotationSessionConflict DocPagesInsertBlank400ResponseCode = "WeakAnnotationSessionConflict" + DocPagesInsertBlank400ResponseCodeLayerVersionConflict DocPagesInsertBlank400ResponseCode = "LayerVersionConflict" + DocPagesInsertBlank400ResponseCodeNotImplemented DocPagesInsertBlank400ResponseCode = "NotImplemented" + DocPagesInsertBlank400ResponseCodeMalformedPdf DocPagesInsertBlank400ResponseCode = "MalformedPdf" ) -func NewDocPagesFlatten400ResponseCodeFromString(s string) (DocPagesFlatten400ResponseCode, error) { +func NewDocPagesInsertBlank400ResponseCodeFromString(s string) (DocPagesInsertBlank400ResponseCode, error) { switch s { case "Unknown": - return DocPagesFlatten400ResponseCodeUnknown, nil + return DocPagesInsertBlank400ResponseCodeUnknown, nil case "InvalidArg": - return DocPagesFlatten400ResponseCodeInvalidArg, nil + return DocPagesInsertBlank400ResponseCodeInvalidArg, nil case "DocNotOpen": - return DocPagesFlatten400ResponseCodeDocNotOpen, nil + return DocPagesInsertBlank400ResponseCodeDocNotOpen, nil case "DocOpenFailed": - return DocPagesFlatten400ResponseCodeDocOpenFailed, nil + return DocPagesInsertBlank400ResponseCodeDocOpenFailed, nil case "DocPasswordRequired": - return DocPagesFlatten400ResponseCodeDocPasswordRequired, nil + return DocPagesInsertBlank400ResponseCodeDocPasswordRequired, nil case "DocPasswordIncorrect": - return DocPagesFlatten400ResponseCodeDocPasswordIncorrect, nil + return DocPagesInsertBlank400ResponseCodeDocPasswordIncorrect, nil case "SharePasswordRequired": - return DocPagesFlatten400ResponseCodeSharePasswordRequired, nil + return DocPagesInsertBlank400ResponseCodeSharePasswordRequired, nil case "Aborted": - return DocPagesFlatten400ResponseCodeAborted, nil + return DocPagesInsertBlank400ResponseCodeAborted, nil case "Network": - return DocPagesFlatten400ResponseCodeNetwork, nil + return DocPagesInsertBlank400ResponseCodeNetwork, nil case "Unauthenticated": - return DocPagesFlatten400ResponseCodeUnauthenticated, nil + return DocPagesInsertBlank400ResponseCodeUnauthenticated, nil case "Forbidden": - return DocPagesFlatten400ResponseCodeForbidden, nil + return DocPagesInsertBlank400ResponseCodeForbidden, nil case "NotFound": - return DocPagesFlatten400ResponseCodeNotFound, nil + return DocPagesInsertBlank400ResponseCodeNotFound, nil case "WireFormat": - return DocPagesFlatten400ResponseCodeWireFormat, nil + return DocPagesInsertBlank400ResponseCodeWireFormat, nil case "RuntimeUnavailable": - return DocPagesFlatten400ResponseCodeRuntimeUnavailable, nil + return DocPagesInsertBlank400ResponseCodeRuntimeUnavailable, nil case "InvalidReference": - return DocPagesFlatten400ResponseCodeInvalidReference, nil + return DocPagesInsertBlank400ResponseCodeInvalidReference, nil case "WeakAnnotationSessionConflict": - return DocPagesFlatten400ResponseCodeWeakAnnotationSessionConflict, nil + return DocPagesInsertBlank400ResponseCodeWeakAnnotationSessionConflict, nil case "LayerVersionConflict": - return DocPagesFlatten400ResponseCodeLayerVersionConflict, nil + return DocPagesInsertBlank400ResponseCodeLayerVersionConflict, nil case "NotImplemented": - return DocPagesFlatten400ResponseCodeNotImplemented, nil + return DocPagesInsertBlank400ResponseCodeNotImplemented, nil case "MalformedPdf": - return DocPagesFlatten400ResponseCodeMalformedPdf, nil + return DocPagesInsertBlank400ResponseCodeMalformedPdf, nil } - var t DocPagesFlatten400ResponseCode + var t DocPagesInsertBlank400ResponseCode return "", fmt.Errorf("%s is not a valid %T", s, t) } -func (d DocPagesFlatten400ResponseCode) Ptr() *DocPagesFlatten400ResponseCode { +func (d DocPagesInsertBlank400ResponseCode) Ptr() *DocPagesInsertBlank400ResponseCode { return &d } -type DocPagesFlatten400ResponseName string +type DocPagesInsertBlank400ResponseName string const ( - DocPagesFlatten400ResponseNameEngineError DocPagesFlatten400ResponseName = "EngineError" + DocPagesInsertBlank400ResponseNameEngineError DocPagesInsertBlank400ResponseName = "EngineError" ) -func NewDocPagesFlatten400ResponseNameFromString(s string) (DocPagesFlatten400ResponseName, error) { +func NewDocPagesInsertBlank400ResponseNameFromString(s string) (DocPagesInsertBlank400ResponseName, error) { switch s { case "EngineError": - return DocPagesFlatten400ResponseNameEngineError, nil + return DocPagesInsertBlank400ResponseNameEngineError, nil } - var t DocPagesFlatten400ResponseName + var t DocPagesInsertBlank400ResponseName return "", fmt.Errorf("%s is not a valid %T", s, t) } -func (d DocPagesFlatten400ResponseName) Ptr() *DocPagesFlatten400ResponseName { +func (d DocPagesInsertBlank400ResponseName) Ptr() *DocPagesInsertBlank400ResponseName { return &d } var ( - docPagesFlatten404ResponseFieldName = big.NewInt(1 << 0) - docPagesFlatten404ResponseFieldCode = big.NewInt(1 << 1) - docPagesFlatten404ResponseFieldMessage = big.NewInt(1 << 2) - docPagesFlatten404ResponseFieldDetails = big.NewInt(1 << 3) + docPagesInsertBlank404ResponseFieldName = big.NewInt(1 << 0) + docPagesInsertBlank404ResponseFieldCode = big.NewInt(1 << 1) + docPagesInsertBlank404ResponseFieldMessage = big.NewInt(1 << 2) + docPagesInsertBlank404ResponseFieldDetails = big.NewInt(1 << 3) ) -type DocPagesFlatten404Response struct { - Name DocPagesFlatten404ResponseName `json:"name" url:"name"` - Code DocPagesFlatten404ResponseCode `json:"code" url:"code"` - Message string `json:"message" url:"message"` - Details map[string]any `json:"details,omitempty" url:"details,omitempty"` +type DocPagesInsertBlank404Response struct { + Name DocPagesInsertBlank404ResponseName `json:"name" url:"name"` + Code DocPagesInsertBlank404ResponseCode `json:"code" url:"code"` + Message string `json:"message" url:"message"` + Details map[string]any `json:"details,omitempty" url:"details,omitempty"` // Private bitmask of fields set to an explicit value and therefore not to be omitted explicitFields *big.Int `json:"-" url:"-"` @@ -173398,42 +176770,42 @@ type DocPagesFlatten404Response struct { rawJSON json.RawMessage } -func (d *DocPagesFlatten404Response) GetName() DocPagesFlatten404ResponseName { +func (d *DocPagesInsertBlank404Response) GetName() DocPagesInsertBlank404ResponseName { if d == nil { return "" } return d.Name } -func (d *DocPagesFlatten404Response) GetCode() DocPagesFlatten404ResponseCode { +func (d *DocPagesInsertBlank404Response) GetCode() DocPagesInsertBlank404ResponseCode { if d == nil { return "" } return d.Code } -func (d *DocPagesFlatten404Response) GetMessage() string { +func (d *DocPagesInsertBlank404Response) GetMessage() string { if d == nil { return "" } return d.Message } -func (d *DocPagesFlatten404Response) GetDetails() map[string]any { +func (d *DocPagesInsertBlank404Response) GetDetails() map[string]any { if d == nil { return nil } return d.Details } -func (d *DocPagesFlatten404Response) GetExtraProperties() map[string]interface{} { +func (d *DocPagesInsertBlank404Response) GetExtraProperties() map[string]interface{} { if d == nil { return nil } return d.extraProperties } -func (d *DocPagesFlatten404Response) require(field *big.Int) { +func (d *DocPagesInsertBlank404Response) require(field *big.Int) { if d.explicitFields == nil { d.explicitFields = big.NewInt(0) } @@ -173442,39 +176814,39 @@ func (d *DocPagesFlatten404Response) require(field *big.Int) { // SetName sets the Name field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten404Response) SetName(name DocPagesFlatten404ResponseName) { +func (d *DocPagesInsertBlank404Response) SetName(name DocPagesInsertBlank404ResponseName) { d.Name = name - d.require(docPagesFlatten404ResponseFieldName) + d.require(docPagesInsertBlank404ResponseFieldName) } // SetCode sets the Code field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten404Response) SetCode(code DocPagesFlatten404ResponseCode) { +func (d *DocPagesInsertBlank404Response) SetCode(code DocPagesInsertBlank404ResponseCode) { d.Code = code - d.require(docPagesFlatten404ResponseFieldCode) + d.require(docPagesInsertBlank404ResponseFieldCode) } // SetMessage sets the Message field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten404Response) SetMessage(message string) { +func (d *DocPagesInsertBlank404Response) SetMessage(message string) { d.Message = message - d.require(docPagesFlatten404ResponseFieldMessage) + d.require(docPagesInsertBlank404ResponseFieldMessage) } // SetDetails sets the Details field and marks it as non-optional; // this prevents an empty or null value for this field from being omitted during serialization. -func (d *DocPagesFlatten404Response) SetDetails(details map[string]any) { +func (d *DocPagesInsertBlank404Response) SetDetails(details map[string]any) { d.Details = details - d.require(docPagesFlatten404ResponseFieldDetails) + d.require(docPagesInsertBlank404ResponseFieldDetails) } -func (d *DocPagesFlatten404Response) UnmarshalJSON(data []byte) error { - type unmarshaler DocPagesFlatten404Response +func (d *DocPagesInsertBlank404Response) UnmarshalJSON(data []byte) error { + type unmarshaler DocPagesInsertBlank404Response var value unmarshaler if err := json.Unmarshal(data, &value); err != nil { return err } - *d = DocPagesFlatten404Response(value) + *d = DocPagesInsertBlank404Response(value) extraProperties, err := internal.ExtractExtraProperties(data, *d) if err != nil { return err @@ -173484,8 +176856,8 @@ func (d *DocPagesFlatten404Response) UnmarshalJSON(data []byte) error { return nil } -func (d *DocPagesFlatten404Response) MarshalJSON() ([]byte, error) { - type embed DocPagesFlatten404Response +func (d *DocPagesInsertBlank404Response) MarshalJSON() ([]byte, error) { + type embed DocPagesInsertBlank404Response var marshaler = struct { embed }{ @@ -173495,7 +176867,7 @@ func (d *DocPagesFlatten404Response) MarshalJSON() ([]byte, error) { return json.Marshal(explicitMarshaler) } -func (d *DocPagesFlatten404Response) String() string { +func (d *DocPagesInsertBlank404Response) String() string { if d == nil { return "" } @@ -173510,99 +176882,99 @@ func (d *DocPagesFlatten404Response) String() string { return fmt.Sprintf("%#v", d) } -type DocPagesFlatten404ResponseCode string +type DocPagesInsertBlank404ResponseCode string const ( - DocPagesFlatten404ResponseCodeUnknown DocPagesFlatten404ResponseCode = "Unknown" - DocPagesFlatten404ResponseCodeInvalidArg DocPagesFlatten404ResponseCode = "InvalidArg" - DocPagesFlatten404ResponseCodeDocNotOpen DocPagesFlatten404ResponseCode = "DocNotOpen" - DocPagesFlatten404ResponseCodeDocOpenFailed DocPagesFlatten404ResponseCode = "DocOpenFailed" - DocPagesFlatten404ResponseCodeDocPasswordRequired DocPagesFlatten404ResponseCode = "DocPasswordRequired" - DocPagesFlatten404ResponseCodeDocPasswordIncorrect DocPagesFlatten404ResponseCode = "DocPasswordIncorrect" - DocPagesFlatten404ResponseCodeSharePasswordRequired DocPagesFlatten404ResponseCode = "SharePasswordRequired" - DocPagesFlatten404ResponseCodeAborted DocPagesFlatten404ResponseCode = "Aborted" - DocPagesFlatten404ResponseCodeNetwork DocPagesFlatten404ResponseCode = "Network" - DocPagesFlatten404ResponseCodeUnauthenticated DocPagesFlatten404ResponseCode = "Unauthenticated" - DocPagesFlatten404ResponseCodeForbidden DocPagesFlatten404ResponseCode = "Forbidden" - DocPagesFlatten404ResponseCodeNotFound DocPagesFlatten404ResponseCode = "NotFound" - DocPagesFlatten404ResponseCodeWireFormat DocPagesFlatten404ResponseCode = "WireFormat" - DocPagesFlatten404ResponseCodeRuntimeUnavailable DocPagesFlatten404ResponseCode = "RuntimeUnavailable" - DocPagesFlatten404ResponseCodeInvalidReference DocPagesFlatten404ResponseCode = "InvalidReference" - DocPagesFlatten404ResponseCodeWeakAnnotationSessionConflict DocPagesFlatten404ResponseCode = "WeakAnnotationSessionConflict" - DocPagesFlatten404ResponseCodeLayerVersionConflict DocPagesFlatten404ResponseCode = "LayerVersionConflict" - DocPagesFlatten404ResponseCodeNotImplemented DocPagesFlatten404ResponseCode = "NotImplemented" - DocPagesFlatten404ResponseCodeMalformedPdf DocPagesFlatten404ResponseCode = "MalformedPdf" + DocPagesInsertBlank404ResponseCodeUnknown DocPagesInsertBlank404ResponseCode = "Unknown" + DocPagesInsertBlank404ResponseCodeInvalidArg DocPagesInsertBlank404ResponseCode = "InvalidArg" + DocPagesInsertBlank404ResponseCodeDocNotOpen DocPagesInsertBlank404ResponseCode = "DocNotOpen" + DocPagesInsertBlank404ResponseCodeDocOpenFailed DocPagesInsertBlank404ResponseCode = "DocOpenFailed" + DocPagesInsertBlank404ResponseCodeDocPasswordRequired DocPagesInsertBlank404ResponseCode = "DocPasswordRequired" + DocPagesInsertBlank404ResponseCodeDocPasswordIncorrect DocPagesInsertBlank404ResponseCode = "DocPasswordIncorrect" + DocPagesInsertBlank404ResponseCodeSharePasswordRequired DocPagesInsertBlank404ResponseCode = "SharePasswordRequired" + DocPagesInsertBlank404ResponseCodeAborted DocPagesInsertBlank404ResponseCode = "Aborted" + DocPagesInsertBlank404ResponseCodeNetwork DocPagesInsertBlank404ResponseCode = "Network" + DocPagesInsertBlank404ResponseCodeUnauthenticated DocPagesInsertBlank404ResponseCode = "Unauthenticated" + DocPagesInsertBlank404ResponseCodeForbidden DocPagesInsertBlank404ResponseCode = "Forbidden" + DocPagesInsertBlank404ResponseCodeNotFound DocPagesInsertBlank404ResponseCode = "NotFound" + DocPagesInsertBlank404ResponseCodeWireFormat DocPagesInsertBlank404ResponseCode = "WireFormat" + DocPagesInsertBlank404ResponseCodeRuntimeUnavailable DocPagesInsertBlank404ResponseCode = "RuntimeUnavailable" + DocPagesInsertBlank404ResponseCodeInvalidReference DocPagesInsertBlank404ResponseCode = "InvalidReference" + DocPagesInsertBlank404ResponseCodeWeakAnnotationSessionConflict DocPagesInsertBlank404ResponseCode = "WeakAnnotationSessionConflict" + DocPagesInsertBlank404ResponseCodeLayerVersionConflict DocPagesInsertBlank404ResponseCode = "LayerVersionConflict" + DocPagesInsertBlank404ResponseCodeNotImplemented DocPagesInsertBlank404ResponseCode = "NotImplemented" + DocPagesInsertBlank404ResponseCodeMalformedPdf DocPagesInsertBlank404ResponseCode = "MalformedPdf" ) -func NewDocPagesFlatten404ResponseCodeFromString(s string) (DocPagesFlatten404ResponseCode, error) { +func NewDocPagesInsertBlank404ResponseCodeFromString(s string) (DocPagesInsertBlank404ResponseCode, error) { switch s { case "Unknown": - return DocPagesFlatten404ResponseCodeUnknown, nil + return DocPagesInsertBlank404ResponseCodeUnknown, nil case "InvalidArg": - return DocPagesFlatten404ResponseCodeInvalidArg, nil + return DocPagesInsertBlank404ResponseCodeInvalidArg, nil case "DocNotOpen": - return DocPagesFlatten404ResponseCodeDocNotOpen, nil + return DocPagesInsertBlank404ResponseCodeDocNotOpen, nil case "DocOpenFailed": - return DocPagesFlatten404ResponseCodeDocOpenFailed, nil + return DocPagesInsertBlank404ResponseCodeDocOpenFailed, nil case "DocPasswordRequired": - return DocPagesFlatten404ResponseCodeDocPasswordRequired, nil + return DocPagesInsertBlank404ResponseCodeDocPasswordRequired, nil case "DocPasswordIncorrect": - return DocPagesFlatten404ResponseCodeDocPasswordIncorrect, nil + return DocPagesInsertBlank404ResponseCodeDocPasswordIncorrect, nil case "SharePasswordRequired": - return DocPagesFlatten404ResponseCodeSharePasswordRequired, nil + return DocPagesInsertBlank404ResponseCodeSharePasswordRequired, nil case "Aborted": - return DocPagesFlatten404ResponseCodeAborted, nil + return DocPagesInsertBlank404ResponseCodeAborted, nil case "Network": - return DocPagesFlatten404ResponseCodeNetwork, nil + return DocPagesInsertBlank404ResponseCodeNetwork, nil case "Unauthenticated": - return DocPagesFlatten404ResponseCodeUnauthenticated, nil + return DocPagesInsertBlank404ResponseCodeUnauthenticated, nil case "Forbidden": - return DocPagesFlatten404ResponseCodeForbidden, nil + return DocPagesInsertBlank404ResponseCodeForbidden, nil case "NotFound": - return DocPagesFlatten404ResponseCodeNotFound, nil + return DocPagesInsertBlank404ResponseCodeNotFound, nil case "WireFormat": - return DocPagesFlatten404ResponseCodeWireFormat, nil + return DocPagesInsertBlank404ResponseCodeWireFormat, nil case "RuntimeUnavailable": - return DocPagesFlatten404ResponseCodeRuntimeUnavailable, nil + return DocPagesInsertBlank404ResponseCodeRuntimeUnavailable, nil case "InvalidReference": - return DocPagesFlatten404ResponseCodeInvalidReference, nil + return DocPagesInsertBlank404ResponseCodeInvalidReference, nil case "WeakAnnotationSessionConflict": - return DocPagesFlatten404ResponseCodeWeakAnnotationSessionConflict, nil + return DocPagesInsertBlank404ResponseCodeWeakAnnotationSessionConflict, nil case "LayerVersionConflict": - return DocPagesFlatten404ResponseCodeLayerVersionConflict, nil + return DocPagesInsertBlank404ResponseCodeLayerVersionConflict, nil case "NotImplemented": - return DocPagesFlatten404ResponseCodeNotImplemented, nil + return DocPagesInsertBlank404ResponseCodeNotImplemented, nil case "MalformedPdf": - return DocPagesFlatten404ResponseCodeMalformedPdf, nil + return DocPagesInsertBlank404ResponseCodeMalformedPdf, nil } - var t DocPagesFlatten404ResponseCode + var t DocPagesInsertBlank404ResponseCode return "", fmt.Errorf("%s is not a valid %T", s, t) } -func (d DocPagesFlatten404ResponseCode) Ptr() *DocPagesFlatten404ResponseCode { +func (d DocPagesInsertBlank404ResponseCode) Ptr() *DocPagesInsertBlank404ResponseCode { return &d } -type DocPagesFlatten404ResponseName string +type DocPagesInsertBlank404ResponseName string const ( - DocPagesFlatten404ResponseNameEngineError DocPagesFlatten404ResponseName = "EngineError" + DocPagesInsertBlank404ResponseNameEngineError DocPagesInsertBlank404ResponseName = "EngineError" ) -func NewDocPagesFlatten404ResponseNameFromString(s string) (DocPagesFlatten404ResponseName, error) { +func NewDocPagesInsertBlank404ResponseNameFromString(s string) (DocPagesInsertBlank404ResponseName, error) { switch s { case "EngineError": - return DocPagesFlatten404ResponseNameEngineError, nil + return DocPagesInsertBlank404ResponseNameEngineError, nil } - var t DocPagesFlatten404ResponseName + var t DocPagesInsertBlank404ResponseName return "", fmt.Errorf("%s is not a valid %T", s, t) } -func (d DocPagesFlatten404ResponseName) Ptr() *DocPagesFlatten404ResponseName { +func (d DocPagesInsertBlank404ResponseName) Ptr() *DocPagesInsertBlank404ResponseName { return &d } -type DocPagesFlattenRequest = map[string]any +type DocPagesInsertBlankRequest = map[string]any var ( docPagesMove200ResponseFieldMeta = big.NewInt(1 << 0) diff --git a/types_test.go b/types_test.go index 148ed1b..1865ca4 100644 --- a/types_test.go +++ b/types_test.go @@ -282592,6 +282592,540 @@ func TestSettersMarkExplicitDocPagesDelete404Response(t *testing.T) { } +func TestSettersDocPagesExtract400Response(t *testing.T) { + t.Run("SetName", func(t *testing.T) { + obj := &DocPagesExtract400Response{} + var fernTestValueName DocPagesExtract400ResponseName + obj.SetName(fernTestValueName) + assert.Equal(t, fernTestValueName, obj.Name) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetCode", func(t *testing.T) { + obj := &DocPagesExtract400Response{} + var fernTestValueCode DocPagesExtract400ResponseCode + obj.SetCode(fernTestValueCode) + assert.Equal(t, fernTestValueCode, obj.Code) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetMessage", func(t *testing.T) { + obj := &DocPagesExtract400Response{} + var fernTestValueMessage string + obj.SetMessage(fernTestValueMessage) + assert.Equal(t, fernTestValueMessage, obj.Message) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetDetails", func(t *testing.T) { + obj := &DocPagesExtract400Response{} + var fernTestValueDetails map[string]any + obj.SetDetails(fernTestValueDetails) + assert.Equal(t, fernTestValueDetails, obj.Details) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocPagesExtract400Response(t *testing.T) { + t.Run("GetName", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract400Response{} + var expected DocPagesExtract400ResponseName + obj.Name = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetName(), "getter should return the property value") + }) + + t.Run("GetName_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesExtract400Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetName() // Should return zero value + }) + + t.Run("GetCode", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract400Response{} + var expected DocPagesExtract400ResponseCode + obj.Code = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetCode(), "getter should return the property value") + }) + + t.Run("GetCode_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesExtract400Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetCode() // Should return zero value + }) + + t.Run("GetMessage", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract400Response{} + var expected string + obj.Message = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetMessage(), "getter should return the property value") + }) + + t.Run("GetMessage_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesExtract400Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetMessage() // Should return zero value + }) + + t.Run("GetDetails", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract400Response{} + var expected map[string]any + obj.Details = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetDetails(), "getter should return the property value") + }) + + t.Run("GetDetails_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract400Response{} + obj.Details = nil + + // Act & Assert + assert.Nil(t, obj.GetDetails(), "getter should return nil when property is nil") + }) + + t.Run("GetDetails_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesExtract400Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetDetails() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocPagesExtract400Response(t *testing.T) { + t.Run("SetName_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract400Response{} + var fernTestValueName DocPagesExtract400ResponseName + + // Act + obj.SetName(fernTestValueName) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetCode_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract400Response{} + var fernTestValueCode DocPagesExtract400ResponseCode + + // Act + obj.SetCode(fernTestValueCode) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetMessage_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract400Response{} + var fernTestValueMessage string + + // Act + obj.SetMessage(fernTestValueMessage) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetDetails_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract400Response{} + var fernTestValueDetails map[string]any + + // Act + obj.SetDetails(fernTestValueDetails) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocPagesExtract404Response(t *testing.T) { + t.Run("SetName", func(t *testing.T) { + obj := &DocPagesExtract404Response{} + var fernTestValueName DocPagesExtract404ResponseName + obj.SetName(fernTestValueName) + assert.Equal(t, fernTestValueName, obj.Name) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetCode", func(t *testing.T) { + obj := &DocPagesExtract404Response{} + var fernTestValueCode DocPagesExtract404ResponseCode + obj.SetCode(fernTestValueCode) + assert.Equal(t, fernTestValueCode, obj.Code) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetMessage", func(t *testing.T) { + obj := &DocPagesExtract404Response{} + var fernTestValueMessage string + obj.SetMessage(fernTestValueMessage) + assert.Equal(t, fernTestValueMessage, obj.Message) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetDetails", func(t *testing.T) { + obj := &DocPagesExtract404Response{} + var fernTestValueDetails map[string]any + obj.SetDetails(fernTestValueDetails) + assert.Equal(t, fernTestValueDetails, obj.Details) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocPagesExtract404Response(t *testing.T) { + t.Run("GetName", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract404Response{} + var expected DocPagesExtract404ResponseName + obj.Name = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetName(), "getter should return the property value") + }) + + t.Run("GetName_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesExtract404Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetName() // Should return zero value + }) + + t.Run("GetCode", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract404Response{} + var expected DocPagesExtract404ResponseCode + obj.Code = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetCode(), "getter should return the property value") + }) + + t.Run("GetCode_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesExtract404Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetCode() // Should return zero value + }) + + t.Run("GetMessage", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract404Response{} + var expected string + obj.Message = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetMessage(), "getter should return the property value") + }) + + t.Run("GetMessage_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesExtract404Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetMessage() // Should return zero value + }) + + t.Run("GetDetails", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract404Response{} + var expected map[string]any + obj.Details = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetDetails(), "getter should return the property value") + }) + + t.Run("GetDetails_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract404Response{} + obj.Details = nil + + // Act & Assert + assert.Nil(t, obj.GetDetails(), "getter should return nil when property is nil") + }) + + t.Run("GetDetails_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesExtract404Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetDetails() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocPagesExtract404Response(t *testing.T) { + t.Run("SetName_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract404Response{} + var fernTestValueName DocPagesExtract404ResponseName + + // Act + obj.SetName(fernTestValueName) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetCode_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract404Response{} + var fernTestValueCode DocPagesExtract404ResponseCode + + // Act + obj.SetCode(fernTestValueCode) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetMessage_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract404Response{} + var fernTestValueMessage string + + // Act + obj.SetMessage(fernTestValueMessage) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetDetails_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract404Response{} + var fernTestValueDetails map[string]any + + // Act + obj.SetDetails(fernTestValueDetails) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + func TestSettersDocPagesFlatten200Response(t *testing.T) { t.Run("SetMeta", func(t *testing.T) { obj := &DocPagesFlatten200Response{} @@ -284414,10 +284948,10 @@ func TestSettersMarkExplicitDocPagesFlatten404Response(t *testing.T) { } -func TestSettersDocPagesMove200Response(t *testing.T) { +func TestSettersDocPagesInsert200Response(t *testing.T) { t.Run("SetMeta", func(t *testing.T) { - obj := &DocPagesMove200Response{} - var fernTestValueMeta *DocPagesMove200ResponseMeta + obj := &DocPagesInsert200Response{} + var fernTestValueMeta *DocPagesInsert200ResponseMeta obj.SetMeta(fernTestValueMeta) assert.Equal(t, fernTestValueMeta, obj.Meta) assert.NotNil(t, obj.explicitFields) @@ -284425,12 +284959,12 @@ func TestSettersDocPagesMove200Response(t *testing.T) { } -func TestGettersDocPagesMove200Response(t *testing.T) { +func TestGettersDocPagesInsert200Response(t *testing.T) { t.Run("GetMeta", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200Response{} - var expected *DocPagesMove200ResponseMeta + obj := &DocPagesInsert200Response{} + var expected *DocPagesInsert200ResponseMeta obj.Meta = expected // Act & Assert @@ -284440,7 +284974,7 @@ func TestGettersDocPagesMove200Response(t *testing.T) { t.Run("GetMeta_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200Response{} + obj := &DocPagesInsert200Response{} obj.Meta = nil // Act & Assert @@ -284449,7 +284983,7 @@ func TestGettersDocPagesMove200Response(t *testing.T) { t.Run("GetMeta_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200Response + var obj *DocPagesInsert200Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -284461,12 +284995,12 @@ func TestGettersDocPagesMove200Response(t *testing.T) { } -func TestSettersMarkExplicitDocPagesMove200Response(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsert200Response(t *testing.T) { t.Run("SetMeta_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200Response{} - var fernTestValueMeta *DocPagesMove200ResponseMeta + obj := &DocPagesInsert200Response{} + var fernTestValueMeta *DocPagesInsert200ResponseMeta // Act obj.SetMeta(fernTestValueMeta) @@ -284495,18 +285029,18 @@ func TestSettersMarkExplicitDocPagesMove200Response(t *testing.T) { } -func TestSettersDocPagesMove200ResponseMeta(t *testing.T) { +func TestSettersDocPagesInsert200ResponseMeta(t *testing.T) { t.Run("SetAffectedPages", func(t *testing.T) { - obj := &DocPagesMove200ResponseMeta{} - var fernTestValueAffectedPages []*DocPagesMove200ResponseMetaAffectedPagesItem + obj := &DocPagesInsert200ResponseMeta{} + var fernTestValueAffectedPages []*DocPagesInsert200ResponseMetaAffectedPagesItem obj.SetAffectedPages(fernTestValueAffectedPages) assert.Equal(t, fernTestValueAffectedPages, obj.AffectedPages) assert.NotNil(t, obj.explicitFields) }) t.Run("SetCacheDelta", func(t *testing.T) { - obj := &DocPagesMove200ResponseMeta{} - var fernTestValueCacheDelta *DocPagesMove200ResponseMetaCacheDelta + obj := &DocPagesInsert200ResponseMeta{} + var fernTestValueCacheDelta *DocPagesInsert200ResponseMetaCacheDelta obj.SetCacheDelta(fernTestValueCacheDelta) assert.Equal(t, fernTestValueCacheDelta, obj.CacheDelta) assert.NotNil(t, obj.explicitFields) @@ -284514,12 +285048,12 @@ func TestSettersDocPagesMove200ResponseMeta(t *testing.T) { } -func TestGettersDocPagesMove200ResponseMeta(t *testing.T) { +func TestGettersDocPagesInsert200ResponseMeta(t *testing.T) { t.Run("GetAffectedPages", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMeta{} - var expected []*DocPagesMove200ResponseMetaAffectedPagesItem + obj := &DocPagesInsert200ResponseMeta{} + var expected []*DocPagesInsert200ResponseMetaAffectedPagesItem obj.AffectedPages = expected // Act & Assert @@ -284529,7 +285063,7 @@ func TestGettersDocPagesMove200ResponseMeta(t *testing.T) { t.Run("GetAffectedPages_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMeta{} + obj := &DocPagesInsert200ResponseMeta{} obj.AffectedPages = nil // Act & Assert @@ -284538,7 +285072,7 @@ func TestGettersDocPagesMove200ResponseMeta(t *testing.T) { t.Run("GetAffectedPages_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMeta + var obj *DocPagesInsert200ResponseMeta // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -284551,8 +285085,8 @@ func TestGettersDocPagesMove200ResponseMeta(t *testing.T) { t.Run("GetCacheDelta", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMeta{} - var expected *DocPagesMove200ResponseMetaCacheDelta + obj := &DocPagesInsert200ResponseMeta{} + var expected *DocPagesInsert200ResponseMetaCacheDelta obj.CacheDelta = expected // Act & Assert @@ -284562,7 +285096,7 @@ func TestGettersDocPagesMove200ResponseMeta(t *testing.T) { t.Run("GetCacheDelta_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMeta{} + obj := &DocPagesInsert200ResponseMeta{} obj.CacheDelta = nil // Act & Assert @@ -284571,7 +285105,7 @@ func TestGettersDocPagesMove200ResponseMeta(t *testing.T) { t.Run("GetCacheDelta_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMeta + var obj *DocPagesInsert200ResponseMeta // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -284583,12 +285117,12 @@ func TestGettersDocPagesMove200ResponseMeta(t *testing.T) { } -func TestSettersMarkExplicitDocPagesMove200ResponseMeta(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsert200ResponseMeta(t *testing.T) { t.Run("SetAffectedPages_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMeta{} - var fernTestValueAffectedPages []*DocPagesMove200ResponseMetaAffectedPagesItem + obj := &DocPagesInsert200ResponseMeta{} + var fernTestValueAffectedPages []*DocPagesInsert200ResponseMetaAffectedPagesItem // Act obj.SetAffectedPages(fernTestValueAffectedPages) @@ -284618,8 +285152,8 @@ func TestSettersMarkExplicitDocPagesMove200ResponseMeta(t *testing.T) { t.Run("SetCacheDelta_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMeta{} - var fernTestValueCacheDelta *DocPagesMove200ResponseMetaCacheDelta + obj := &DocPagesInsert200ResponseMeta{} + var fernTestValueCacheDelta *DocPagesInsert200ResponseMetaCacheDelta // Act obj.SetCacheDelta(fernTestValueCacheDelta) @@ -284648,9 +285182,9 @@ func TestSettersMarkExplicitDocPagesMove200ResponseMeta(t *testing.T) { } -func TestSettersDocPagesMove200ResponseMetaAffectedPagesItem(t *testing.T) { +func TestSettersDocPagesInsert200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("SetPageObjectNumber", func(t *testing.T) { - obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItem{} var fernTestValuePageObjectNumber int obj.SetPageObjectNumber(fernTestValuePageObjectNumber) assert.Equal(t, fernTestValuePageObjectNumber, obj.PageObjectNumber) @@ -284658,16 +285192,16 @@ func TestSettersDocPagesMove200ResponseMetaAffectedPagesItem(t *testing.T) { }) t.Run("SetRevision", func(t *testing.T) { - obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} - var fernTestValueRevision *DocPagesMove200ResponseMetaAffectedPagesItemRevision + obj := &DocPagesInsert200ResponseMetaAffectedPagesItem{} + var fernTestValueRevision *DocPagesInsert200ResponseMetaAffectedPagesItemRevision obj.SetRevision(fernTestValueRevision) assert.Equal(t, fernTestValueRevision, obj.Revision) assert.NotNil(t, obj.explicitFields) }) t.Run("SetWeakAnnotationState", func(t *testing.T) { - obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} - var fernTestValueWeakAnnotationState *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState + obj := &DocPagesInsert200ResponseMetaAffectedPagesItem{} + var fernTestValueWeakAnnotationState *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState obj.SetWeakAnnotationState(fernTestValueWeakAnnotationState) assert.Equal(t, fernTestValueWeakAnnotationState, obj.WeakAnnotationState) assert.NotNil(t, obj.explicitFields) @@ -284675,11 +285209,11 @@ func TestSettersDocPagesMove200ResponseMetaAffectedPagesItem(t *testing.T) { } -func TestGettersDocPagesMove200ResponseMetaAffectedPagesItem(t *testing.T) { +func TestGettersDocPagesInsert200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetPageObjectNumber", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItem{} var expected int obj.PageObjectNumber = expected @@ -284689,7 +285223,7 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetPageObjectNumber_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaAffectedPagesItem + var obj *DocPagesInsert200ResponseMetaAffectedPagesItem // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -284702,8 +285236,8 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetRevision", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} - var expected *DocPagesMove200ResponseMetaAffectedPagesItemRevision + obj := &DocPagesInsert200ResponseMetaAffectedPagesItem{} + var expected *DocPagesInsert200ResponseMetaAffectedPagesItemRevision obj.Revision = expected // Act & Assert @@ -284713,7 +285247,7 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetRevision_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItem{} obj.Revision = nil // Act & Assert @@ -284722,7 +285256,7 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetRevision_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaAffectedPagesItem + var obj *DocPagesInsert200ResponseMetaAffectedPagesItem // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -284735,8 +285269,8 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetWeakAnnotationState", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} - var expected *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState + obj := &DocPagesInsert200ResponseMetaAffectedPagesItem{} + var expected *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState obj.WeakAnnotationState = expected // Act & Assert @@ -284746,7 +285280,7 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetWeakAnnotationState_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItem{} obj.WeakAnnotationState = nil // Act & Assert @@ -284755,7 +285289,7 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetWeakAnnotationState_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaAffectedPagesItem + var obj *DocPagesInsert200ResponseMetaAffectedPagesItem // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -284767,11 +285301,11 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItem(t *testing.T) { } -func TestSettersMarkExplicitDocPagesMove200ResponseMetaAffectedPagesItem(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsert200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("SetPageObjectNumber_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItem{} var fernTestValuePageObjectNumber int // Act @@ -284802,8 +285336,8 @@ func TestSettersMarkExplicitDocPagesMove200ResponseMetaAffectedPagesItem(t *test t.Run("SetRevision_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} - var fernTestValueRevision *DocPagesMove200ResponseMetaAffectedPagesItemRevision + obj := &DocPagesInsert200ResponseMetaAffectedPagesItem{} + var fernTestValueRevision *DocPagesInsert200ResponseMetaAffectedPagesItemRevision // Act obj.SetRevision(fernTestValueRevision) @@ -284833,8 +285367,8 @@ func TestSettersMarkExplicitDocPagesMove200ResponseMetaAffectedPagesItem(t *test t.Run("SetWeakAnnotationState_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} - var fernTestValueWeakAnnotationState *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState + obj := &DocPagesInsert200ResponseMetaAffectedPagesItem{} + var fernTestValueWeakAnnotationState *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState // Act obj.SetWeakAnnotationState(fernTestValueWeakAnnotationState) @@ -284863,9 +285397,9 @@ func TestSettersMarkExplicitDocPagesMove200ResponseMetaAffectedPagesItem(t *test } -func TestSettersDocPagesMove200ResponseMetaAffectedPagesItemRevision(t *testing.T) { +func TestSettersDocPagesInsert200ResponseMetaAffectedPagesItemRevision(t *testing.T) { t.Run("SetDocSessionID", func(t *testing.T) { - obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemRevision{} var fernTestValueDocSessionID string obj.SetDocSessionID(fernTestValueDocSessionID) assert.Equal(t, fernTestValueDocSessionID, obj.DocSessionID) @@ -284873,7 +285407,7 @@ func TestSettersDocPagesMove200ResponseMetaAffectedPagesItemRevision(t *testing. }) t.Run("SetPageObjectNumber", func(t *testing.T) { - obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemRevision{} var fernTestValuePageObjectNumber int obj.SetPageObjectNumber(fernTestValuePageObjectNumber) assert.Equal(t, fernTestValuePageObjectNumber, obj.PageObjectNumber) @@ -284881,7 +285415,7 @@ func TestSettersDocPagesMove200ResponseMetaAffectedPagesItemRevision(t *testing. }) t.Run("SetGeneration", func(t *testing.T) { - obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemRevision{} var fernTestValueGeneration int obj.SetGeneration(fernTestValueGeneration) assert.Equal(t, fernTestValueGeneration, obj.Generation) @@ -284890,11 +285424,11 @@ func TestSettersDocPagesMove200ResponseMetaAffectedPagesItemRevision(t *testing. } -func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemRevision(t *testing.T) { +func TestGettersDocPagesInsert200ResponseMetaAffectedPagesItemRevision(t *testing.T) { t.Run("GetDocSessionID", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemRevision{} var expected string obj.DocSessionID = expected @@ -284904,7 +285438,7 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemRevision(t *testing. t.Run("GetDocSessionID_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaAffectedPagesItemRevision + var obj *DocPagesInsert200ResponseMetaAffectedPagesItemRevision // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -284917,7 +285451,7 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemRevision(t *testing. t.Run("GetPageObjectNumber", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemRevision{} var expected int obj.PageObjectNumber = expected @@ -284927,7 +285461,7 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemRevision(t *testing. t.Run("GetPageObjectNumber_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaAffectedPagesItemRevision + var obj *DocPagesInsert200ResponseMetaAffectedPagesItemRevision // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -284940,7 +285474,7 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemRevision(t *testing. t.Run("GetGeneration", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemRevision{} var expected int obj.Generation = expected @@ -284950,7 +285484,7 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemRevision(t *testing. t.Run("GetGeneration_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaAffectedPagesItemRevision + var obj *DocPagesInsert200ResponseMetaAffectedPagesItemRevision // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -284962,11 +285496,11 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemRevision(t *testing. } -func TestSettersMarkExplicitDocPagesMove200ResponseMetaAffectedPagesItemRevision(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsert200ResponseMetaAffectedPagesItemRevision(t *testing.T) { t.Run("SetDocSessionID_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemRevision{} var fernTestValueDocSessionID string // Act @@ -284997,7 +285531,7 @@ func TestSettersMarkExplicitDocPagesMove200ResponseMetaAffectedPagesItemRevision t.Run("SetPageObjectNumber_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemRevision{} var fernTestValuePageObjectNumber int // Act @@ -285028,7 +285562,7 @@ func TestSettersMarkExplicitDocPagesMove200ResponseMetaAffectedPagesItemRevision t.Run("SetGeneration_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemRevision{} var fernTestValueGeneration int // Act @@ -285058,11 +285592,11 @@ func TestSettersMarkExplicitDocPagesMove200ResponseMetaAffectedPagesItemRevision } -func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState(t *testing.T) { +func TestGettersDocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState(t *testing.T) { t.Run("GetKind", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState{} var expected string obj.Kind = expected @@ -285072,7 +285606,7 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState( t.Run("GetKind_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState + var obj *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -285085,8 +285619,8 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState( t.Run("GetUnknown", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState{} - var expected *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState{} + var expected *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown obj.Unknown = expected // Act & Assert @@ -285096,7 +285630,7 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState( t.Run("GetUnknown_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState{} obj.Unknown = nil // Act & Assert @@ -285105,7 +285639,7 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState( t.Run("GetUnknown_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState + var obj *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -285118,8 +285652,8 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState( t.Run("GetKnown", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState{} - var expected *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState{} + var expected *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown obj.Known = expected // Act & Assert @@ -285129,7 +285663,7 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState( t.Run("GetKnown_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState{} obj.Known = nil // Act & Assert @@ -285138,7 +285672,7 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState( t.Run("GetKnown_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState + var obj *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationState // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -285150,9 +285684,9 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState( } -func TestSettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { +func TestSettersDocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { t.Run("SetHasAnyWeakAnnotations", func(t *testing.T) { - obj := &DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} var fernTestValueHasAnyWeakAnnotations bool obj.SetHasAnyWeakAnnotations(fernTestValueHasAnyWeakAnnotations) assert.Equal(t, fernTestValueHasAnyWeakAnnotations, obj.HasAnyWeakAnnotations) @@ -285161,11 +285695,11 @@ func TestSettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateK } -func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { +func TestGettersDocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { t.Run("GetHasAnyWeakAnnotations", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} var expected bool obj.HasAnyWeakAnnotations = expected @@ -285175,7 +285709,7 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateK t.Run("GetHasAnyWeakAnnotations_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + var obj *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -285187,11 +285721,11 @@ func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateK } -func TestSettersMarkExplicitDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { t.Run("SetHasAnyWeakAnnotations_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} var fernTestValueHasAnyWeakAnnotations bool // Act @@ -285221,9 +285755,9 @@ func TestSettersMarkExplicitDocPagesMove200ResponseMetaAffectedPagesItemWeakAnno } -func TestSettersDocPagesMove200ResponseMetaCacheDelta(t *testing.T) { +func TestSettersDocPagesInsert200ResponseMetaCacheDelta(t *testing.T) { t.Run("SetPreviousDocVersion", func(t *testing.T) { - obj := &DocPagesMove200ResponseMetaCacheDelta{} + obj := &DocPagesInsert200ResponseMetaCacheDelta{} var fernTestValuePreviousDocVersion int obj.SetPreviousDocVersion(fernTestValuePreviousDocVersion) assert.Equal(t, fernTestValuePreviousDocVersion, obj.PreviousDocVersion) @@ -285231,7 +285765,7 @@ func TestSettersDocPagesMove200ResponseMetaCacheDelta(t *testing.T) { }) t.Run("SetDocVersion", func(t *testing.T) { - obj := &DocPagesMove200ResponseMetaCacheDelta{} + obj := &DocPagesInsert200ResponseMetaCacheDelta{} var fernTestValueDocVersion int obj.SetDocVersion(fernTestValueDocVersion) assert.Equal(t, fernTestValueDocVersion, obj.DocVersion) @@ -285239,8 +285773,8 @@ func TestSettersDocPagesMove200ResponseMetaCacheDelta(t *testing.T) { }) t.Run("SetPages", func(t *testing.T) { - obj := &DocPagesMove200ResponseMetaCacheDelta{} - var fernTestValuePages []*DocPagesMove200ResponseMetaCacheDeltaPagesItem + obj := &DocPagesInsert200ResponseMetaCacheDelta{} + var fernTestValuePages []*DocPagesInsert200ResponseMetaCacheDeltaPagesItem obj.SetPages(fernTestValuePages) assert.Equal(t, fernTestValuePages, obj.Pages) assert.NotNil(t, obj.explicitFields) @@ -285248,11 +285782,11 @@ func TestSettersDocPagesMove200ResponseMetaCacheDelta(t *testing.T) { } -func TestGettersDocPagesMove200ResponseMetaCacheDelta(t *testing.T) { +func TestGettersDocPagesInsert200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetPreviousDocVersion", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaCacheDelta{} + obj := &DocPagesInsert200ResponseMetaCacheDelta{} var expected int obj.PreviousDocVersion = expected @@ -285262,7 +285796,7 @@ func TestGettersDocPagesMove200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetPreviousDocVersion_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaCacheDelta + var obj *DocPagesInsert200ResponseMetaCacheDelta // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -285275,7 +285809,7 @@ func TestGettersDocPagesMove200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetDocVersion", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaCacheDelta{} + obj := &DocPagesInsert200ResponseMetaCacheDelta{} var expected int obj.DocVersion = expected @@ -285285,7 +285819,7 @@ func TestGettersDocPagesMove200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetDocVersion_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaCacheDelta + var obj *DocPagesInsert200ResponseMetaCacheDelta // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -285298,8 +285832,8 @@ func TestGettersDocPagesMove200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetPages", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaCacheDelta{} - var expected []*DocPagesMove200ResponseMetaCacheDeltaPagesItem + obj := &DocPagesInsert200ResponseMetaCacheDelta{} + var expected []*DocPagesInsert200ResponseMetaCacheDeltaPagesItem obj.Pages = expected // Act & Assert @@ -285309,7 +285843,7 @@ func TestGettersDocPagesMove200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetPages_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaCacheDelta{} + obj := &DocPagesInsert200ResponseMetaCacheDelta{} obj.Pages = nil // Act & Assert @@ -285318,7 +285852,7 @@ func TestGettersDocPagesMove200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetPages_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaCacheDelta + var obj *DocPagesInsert200ResponseMetaCacheDelta // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -285330,11 +285864,11 @@ func TestGettersDocPagesMove200ResponseMetaCacheDelta(t *testing.T) { } -func TestSettersMarkExplicitDocPagesMove200ResponseMetaCacheDelta(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsert200ResponseMetaCacheDelta(t *testing.T) { t.Run("SetPreviousDocVersion_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaCacheDelta{} + obj := &DocPagesInsert200ResponseMetaCacheDelta{} var fernTestValuePreviousDocVersion int // Act @@ -285365,7 +285899,7 @@ func TestSettersMarkExplicitDocPagesMove200ResponseMetaCacheDelta(t *testing.T) t.Run("SetDocVersion_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaCacheDelta{} + obj := &DocPagesInsert200ResponseMetaCacheDelta{} var fernTestValueDocVersion int // Act @@ -285396,8 +285930,8 @@ func TestSettersMarkExplicitDocPagesMove200ResponseMetaCacheDelta(t *testing.T) t.Run("SetPages_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaCacheDelta{} - var fernTestValuePages []*DocPagesMove200ResponseMetaCacheDeltaPagesItem + obj := &DocPagesInsert200ResponseMetaCacheDelta{} + var fernTestValuePages []*DocPagesInsert200ResponseMetaCacheDeltaPagesItem // Act obj.SetPages(fernTestValuePages) @@ -285426,9 +285960,9 @@ func TestSettersMarkExplicitDocPagesMove200ResponseMetaCacheDelta(t *testing.T) } -func TestSettersDocPagesMove200ResponseMetaCacheDeltaPagesItem(t *testing.T) { +func TestSettersDocPagesInsert200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("SetPageObjectNumber", func(t *testing.T) { - obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItem{} + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItem{} var fernTestValuePageObjectNumber int obj.SetPageObjectNumber(fernTestValuePageObjectNumber) assert.Equal(t, fernTestValuePageObjectNumber, obj.PageObjectNumber) @@ -285436,8 +285970,8 @@ func TestSettersDocPagesMove200ResponseMetaCacheDeltaPagesItem(t *testing.T) { }) t.Run("SetCache", func(t *testing.T) { - obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItem{} - var fernTestValueCache *DocPagesMove200ResponseMetaCacheDeltaPagesItemCache + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItem{} + var fernTestValueCache *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache obj.SetCache(fernTestValueCache) assert.Equal(t, fernTestValueCache, obj.Cache) assert.NotNil(t, obj.explicitFields) @@ -285445,11 +285979,11 @@ func TestSettersDocPagesMove200ResponseMetaCacheDeltaPagesItem(t *testing.T) { } -func TestGettersDocPagesMove200ResponseMetaCacheDeltaPagesItem(t *testing.T) { +func TestGettersDocPagesInsert200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("GetPageObjectNumber", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItem{} + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItem{} var expected int obj.PageObjectNumber = expected @@ -285459,7 +285993,7 @@ func TestGettersDocPagesMove200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("GetPageObjectNumber_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaCacheDeltaPagesItem + var obj *DocPagesInsert200ResponseMetaCacheDeltaPagesItem // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -285472,8 +286006,8 @@ func TestGettersDocPagesMove200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("GetCache", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItem{} - var expected *DocPagesMove200ResponseMetaCacheDeltaPagesItemCache + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItem{} + var expected *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache obj.Cache = expected // Act & Assert @@ -285483,7 +286017,7 @@ func TestGettersDocPagesMove200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("GetCache_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItem{} + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItem{} obj.Cache = nil // Act & Assert @@ -285492,7 +286026,7 @@ func TestGettersDocPagesMove200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("GetCache_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaCacheDeltaPagesItem + var obj *DocPagesInsert200ResponseMetaCacheDeltaPagesItem // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -285504,11 +286038,11 @@ func TestGettersDocPagesMove200ResponseMetaCacheDeltaPagesItem(t *testing.T) { } -func TestSettersMarkExplicitDocPagesMove200ResponseMetaCacheDeltaPagesItem(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsert200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("SetPageObjectNumber_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItem{} + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItem{} var fernTestValuePageObjectNumber int // Act @@ -285539,8 +286073,8 @@ func TestSettersMarkExplicitDocPagesMove200ResponseMetaCacheDeltaPagesItem(t *te t.Run("SetCache_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItem{} - var fernTestValueCache *DocPagesMove200ResponseMetaCacheDeltaPagesItemCache + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItem{} + var fernTestValueCache *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache // Act obj.SetCache(fernTestValueCache) @@ -285569,9 +286103,9 @@ func TestSettersMarkExplicitDocPagesMove200ResponseMetaCacheDeltaPagesItem(t *te } -func TestSettersDocPagesMove200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { +func TestSettersDocPagesInsert200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { t.Run("SetContentVersion", func(t *testing.T) { - obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache{} var fernTestValueContentVersion int obj.SetContentVersion(fernTestValueContentVersion) assert.Equal(t, fernTestValueContentVersion, obj.ContentVersion) @@ -285579,7 +286113,7 @@ func TestSettersDocPagesMove200ResponseMetaCacheDeltaPagesItemCache(t *testing.T }) t.Run("SetAnnotationVersion", func(t *testing.T) { - obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache{} var fernTestValueAnnotationVersion int obj.SetAnnotationVersion(fernTestValueAnnotationVersion) assert.Equal(t, fernTestValueAnnotationVersion, obj.AnnotationVersion) @@ -285588,11 +286122,11 @@ func TestSettersDocPagesMove200ResponseMetaCacheDeltaPagesItemCache(t *testing.T } -func TestGettersDocPagesMove200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { +func TestGettersDocPagesInsert200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { t.Run("GetContentVersion", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache{} var expected int obj.ContentVersion = expected @@ -285602,7 +286136,7 @@ func TestGettersDocPagesMove200ResponseMetaCacheDeltaPagesItemCache(t *testing.T t.Run("GetContentVersion_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaCacheDeltaPagesItemCache + var obj *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -285615,7 +286149,7 @@ func TestGettersDocPagesMove200ResponseMetaCacheDeltaPagesItemCache(t *testing.T t.Run("GetAnnotationVersion", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache{} var expected int obj.AnnotationVersion = expected @@ -285625,7 +286159,7 @@ func TestGettersDocPagesMove200ResponseMetaCacheDeltaPagesItemCache(t *testing.T t.Run("GetAnnotationVersion_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove200ResponseMetaCacheDeltaPagesItemCache + var obj *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -285637,11 +286171,11 @@ func TestGettersDocPagesMove200ResponseMetaCacheDeltaPagesItemCache(t *testing.T } -func TestSettersMarkExplicitDocPagesMove200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsert200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { t.Run("SetContentVersion_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache{} var fernTestValueContentVersion int // Act @@ -285672,7 +286206,7 @@ func TestSettersMarkExplicitDocPagesMove200ResponseMetaCacheDeltaPagesItemCache( t.Run("SetAnnotationVersion_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache{} var fernTestValueAnnotationVersion int // Act @@ -285702,25 +286236,25 @@ func TestSettersMarkExplicitDocPagesMove200ResponseMetaCacheDeltaPagesItemCache( } -func TestSettersDocPagesMove400Response(t *testing.T) { +func TestSettersDocPagesInsert400Response(t *testing.T) { t.Run("SetName", func(t *testing.T) { - obj := &DocPagesMove400Response{} - var fernTestValueName DocPagesMove400ResponseName + obj := &DocPagesInsert400Response{} + var fernTestValueName DocPagesInsert400ResponseName obj.SetName(fernTestValueName) assert.Equal(t, fernTestValueName, obj.Name) assert.NotNil(t, obj.explicitFields) }) t.Run("SetCode", func(t *testing.T) { - obj := &DocPagesMove400Response{} - var fernTestValueCode DocPagesMove400ResponseCode + obj := &DocPagesInsert400Response{} + var fernTestValueCode DocPagesInsert400ResponseCode obj.SetCode(fernTestValueCode) assert.Equal(t, fernTestValueCode, obj.Code) assert.NotNil(t, obj.explicitFields) }) t.Run("SetMessage", func(t *testing.T) { - obj := &DocPagesMove400Response{} + obj := &DocPagesInsert400Response{} var fernTestValueMessage string obj.SetMessage(fernTestValueMessage) assert.Equal(t, fernTestValueMessage, obj.Message) @@ -285728,7 +286262,7 @@ func TestSettersDocPagesMove400Response(t *testing.T) { }) t.Run("SetDetails", func(t *testing.T) { - obj := &DocPagesMove400Response{} + obj := &DocPagesInsert400Response{} var fernTestValueDetails map[string]any obj.SetDetails(fernTestValueDetails) assert.Equal(t, fernTestValueDetails, obj.Details) @@ -285737,12 +286271,12 @@ func TestSettersDocPagesMove400Response(t *testing.T) { } -func TestGettersDocPagesMove400Response(t *testing.T) { +func TestGettersDocPagesInsert400Response(t *testing.T) { t.Run("GetName", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove400Response{} - var expected DocPagesMove400ResponseName + obj := &DocPagesInsert400Response{} + var expected DocPagesInsert400ResponseName obj.Name = expected // Act & Assert @@ -285751,7 +286285,7 @@ func TestGettersDocPagesMove400Response(t *testing.T) { t.Run("GetName_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove400Response + var obj *DocPagesInsert400Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -285764,8 +286298,8 @@ func TestGettersDocPagesMove400Response(t *testing.T) { t.Run("GetCode", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove400Response{} - var expected DocPagesMove400ResponseCode + obj := &DocPagesInsert400Response{} + var expected DocPagesInsert400ResponseCode obj.Code = expected // Act & Assert @@ -285774,7 +286308,7 @@ func TestGettersDocPagesMove400Response(t *testing.T) { t.Run("GetCode_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove400Response + var obj *DocPagesInsert400Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -285787,7 +286321,7 @@ func TestGettersDocPagesMove400Response(t *testing.T) { t.Run("GetMessage", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove400Response{} + obj := &DocPagesInsert400Response{} var expected string obj.Message = expected @@ -285797,7 +286331,7 @@ func TestGettersDocPagesMove400Response(t *testing.T) { t.Run("GetMessage_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove400Response + var obj *DocPagesInsert400Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -285810,7 +286344,7 @@ func TestGettersDocPagesMove400Response(t *testing.T) { t.Run("GetDetails", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove400Response{} + obj := &DocPagesInsert400Response{} var expected map[string]any obj.Details = expected @@ -285821,7 +286355,7 @@ func TestGettersDocPagesMove400Response(t *testing.T) { t.Run("GetDetails_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove400Response{} + obj := &DocPagesInsert400Response{} obj.Details = nil // Act & Assert @@ -285830,7 +286364,7 @@ func TestGettersDocPagesMove400Response(t *testing.T) { t.Run("GetDetails_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove400Response + var obj *DocPagesInsert400Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -285842,12 +286376,12 @@ func TestGettersDocPagesMove400Response(t *testing.T) { } -func TestSettersMarkExplicitDocPagesMove400Response(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsert400Response(t *testing.T) { t.Run("SetName_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove400Response{} - var fernTestValueName DocPagesMove400ResponseName + obj := &DocPagesInsert400Response{} + var fernTestValueName DocPagesInsert400ResponseName // Act obj.SetName(fernTestValueName) @@ -285877,8 +286411,8 @@ func TestSettersMarkExplicitDocPagesMove400Response(t *testing.T) { t.Run("SetCode_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove400Response{} - var fernTestValueCode DocPagesMove400ResponseCode + obj := &DocPagesInsert400Response{} + var fernTestValueCode DocPagesInsert400ResponseCode // Act obj.SetCode(fernTestValueCode) @@ -285908,7 +286442,7 @@ func TestSettersMarkExplicitDocPagesMove400Response(t *testing.T) { t.Run("SetMessage_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove400Response{} + obj := &DocPagesInsert400Response{} var fernTestValueMessage string // Act @@ -285939,7 +286473,7 @@ func TestSettersMarkExplicitDocPagesMove400Response(t *testing.T) { t.Run("SetDetails_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove400Response{} + obj := &DocPagesInsert400Response{} var fernTestValueDetails map[string]any // Act @@ -285969,25 +286503,25 @@ func TestSettersMarkExplicitDocPagesMove400Response(t *testing.T) { } -func TestSettersDocPagesMove404Response(t *testing.T) { +func TestSettersDocPagesInsert404Response(t *testing.T) { t.Run("SetName", func(t *testing.T) { - obj := &DocPagesMove404Response{} - var fernTestValueName DocPagesMove404ResponseName + obj := &DocPagesInsert404Response{} + var fernTestValueName DocPagesInsert404ResponseName obj.SetName(fernTestValueName) assert.Equal(t, fernTestValueName, obj.Name) assert.NotNil(t, obj.explicitFields) }) t.Run("SetCode", func(t *testing.T) { - obj := &DocPagesMove404Response{} - var fernTestValueCode DocPagesMove404ResponseCode + obj := &DocPagesInsert404Response{} + var fernTestValueCode DocPagesInsert404ResponseCode obj.SetCode(fernTestValueCode) assert.Equal(t, fernTestValueCode, obj.Code) assert.NotNil(t, obj.explicitFields) }) t.Run("SetMessage", func(t *testing.T) { - obj := &DocPagesMove404Response{} + obj := &DocPagesInsert404Response{} var fernTestValueMessage string obj.SetMessage(fernTestValueMessage) assert.Equal(t, fernTestValueMessage, obj.Message) @@ -285995,7 +286529,7 @@ func TestSettersDocPagesMove404Response(t *testing.T) { }) t.Run("SetDetails", func(t *testing.T) { - obj := &DocPagesMove404Response{} + obj := &DocPagesInsert404Response{} var fernTestValueDetails map[string]any obj.SetDetails(fernTestValueDetails) assert.Equal(t, fernTestValueDetails, obj.Details) @@ -286004,12 +286538,12 @@ func TestSettersDocPagesMove404Response(t *testing.T) { } -func TestGettersDocPagesMove404Response(t *testing.T) { +func TestGettersDocPagesInsert404Response(t *testing.T) { t.Run("GetName", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove404Response{} - var expected DocPagesMove404ResponseName + obj := &DocPagesInsert404Response{} + var expected DocPagesInsert404ResponseName obj.Name = expected // Act & Assert @@ -286018,7 +286552,7 @@ func TestGettersDocPagesMove404Response(t *testing.T) { t.Run("GetName_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove404Response + var obj *DocPagesInsert404Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -286031,8 +286565,8 @@ func TestGettersDocPagesMove404Response(t *testing.T) { t.Run("GetCode", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove404Response{} - var expected DocPagesMove404ResponseCode + obj := &DocPagesInsert404Response{} + var expected DocPagesInsert404ResponseCode obj.Code = expected // Act & Assert @@ -286041,7 +286575,7 @@ func TestGettersDocPagesMove404Response(t *testing.T) { t.Run("GetCode_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove404Response + var obj *DocPagesInsert404Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -286054,7 +286588,7 @@ func TestGettersDocPagesMove404Response(t *testing.T) { t.Run("GetMessage", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove404Response{} + obj := &DocPagesInsert404Response{} var expected string obj.Message = expected @@ -286064,7 +286598,7 @@ func TestGettersDocPagesMove404Response(t *testing.T) { t.Run("GetMessage_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove404Response + var obj *DocPagesInsert404Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -286077,7 +286611,7 @@ func TestGettersDocPagesMove404Response(t *testing.T) { t.Run("GetDetails", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove404Response{} + obj := &DocPagesInsert404Response{} var expected map[string]any obj.Details = expected @@ -286088,7 +286622,7 @@ func TestGettersDocPagesMove404Response(t *testing.T) { t.Run("GetDetails_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove404Response{} + obj := &DocPagesInsert404Response{} obj.Details = nil // Act & Assert @@ -286097,7 +286631,7 @@ func TestGettersDocPagesMove404Response(t *testing.T) { t.Run("GetDetails_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesMove404Response + var obj *DocPagesInsert404Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -286109,12 +286643,12 @@ func TestGettersDocPagesMove404Response(t *testing.T) { } -func TestSettersMarkExplicitDocPagesMove404Response(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsert404Response(t *testing.T) { t.Run("SetName_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove404Response{} - var fernTestValueName DocPagesMove404ResponseName + obj := &DocPagesInsert404Response{} + var fernTestValueName DocPagesInsert404ResponseName // Act obj.SetName(fernTestValueName) @@ -286144,8 +286678,8 @@ func TestSettersMarkExplicitDocPagesMove404Response(t *testing.T) { t.Run("SetCode_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove404Response{} - var fernTestValueCode DocPagesMove404ResponseCode + obj := &DocPagesInsert404Response{} + var fernTestValueCode DocPagesInsert404ResponseCode // Act obj.SetCode(fernTestValueCode) @@ -286175,7 +286709,7 @@ func TestSettersMarkExplicitDocPagesMove404Response(t *testing.T) { t.Run("SetMessage_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove404Response{} + obj := &DocPagesInsert404Response{} var fernTestValueMessage string // Act @@ -286206,7 +286740,7 @@ func TestSettersMarkExplicitDocPagesMove404Response(t *testing.T) { t.Run("SetDetails_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesMove404Response{} + obj := &DocPagesInsert404Response{} var fernTestValueDetails map[string]any // Act @@ -286236,10 +286770,10 @@ func TestSettersMarkExplicitDocPagesMove404Response(t *testing.T) { } -func TestSettersDocPagesRotate200Response(t *testing.T) { +func TestSettersDocPagesInsertBlank200Response(t *testing.T) { t.Run("SetMeta", func(t *testing.T) { - obj := &DocPagesRotate200Response{} - var fernTestValueMeta *DocPagesRotate200ResponseMeta + obj := &DocPagesInsertBlank200Response{} + var fernTestValueMeta *DocPagesInsertBlank200ResponseMeta obj.SetMeta(fernTestValueMeta) assert.Equal(t, fernTestValueMeta, obj.Meta) assert.NotNil(t, obj.explicitFields) @@ -286247,12 +286781,12 @@ func TestSettersDocPagesRotate200Response(t *testing.T) { } -func TestGettersDocPagesRotate200Response(t *testing.T) { +func TestGettersDocPagesInsertBlank200Response(t *testing.T) { t.Run("GetMeta", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200Response{} - var expected *DocPagesRotate200ResponseMeta + obj := &DocPagesInsertBlank200Response{} + var expected *DocPagesInsertBlank200ResponseMeta obj.Meta = expected // Act & Assert @@ -286262,7 +286796,7 @@ func TestGettersDocPagesRotate200Response(t *testing.T) { t.Run("GetMeta_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200Response{} + obj := &DocPagesInsertBlank200Response{} obj.Meta = nil // Act & Assert @@ -286271,7 +286805,7 @@ func TestGettersDocPagesRotate200Response(t *testing.T) { t.Run("GetMeta_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200Response + var obj *DocPagesInsertBlank200Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -286283,12 +286817,12 @@ func TestGettersDocPagesRotate200Response(t *testing.T) { } -func TestSettersMarkExplicitDocPagesRotate200Response(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsertBlank200Response(t *testing.T) { t.Run("SetMeta_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200Response{} - var fernTestValueMeta *DocPagesRotate200ResponseMeta + obj := &DocPagesInsertBlank200Response{} + var fernTestValueMeta *DocPagesInsertBlank200ResponseMeta // Act obj.SetMeta(fernTestValueMeta) @@ -286317,18 +286851,18 @@ func TestSettersMarkExplicitDocPagesRotate200Response(t *testing.T) { } -func TestSettersDocPagesRotate200ResponseMeta(t *testing.T) { +func TestSettersDocPagesInsertBlank200ResponseMeta(t *testing.T) { t.Run("SetAffectedPages", func(t *testing.T) { - obj := &DocPagesRotate200ResponseMeta{} - var fernTestValueAffectedPages []*DocPagesRotate200ResponseMetaAffectedPagesItem + obj := &DocPagesInsertBlank200ResponseMeta{} + var fernTestValueAffectedPages []*DocPagesInsertBlank200ResponseMetaAffectedPagesItem obj.SetAffectedPages(fernTestValueAffectedPages) assert.Equal(t, fernTestValueAffectedPages, obj.AffectedPages) assert.NotNil(t, obj.explicitFields) }) t.Run("SetCacheDelta", func(t *testing.T) { - obj := &DocPagesRotate200ResponseMeta{} - var fernTestValueCacheDelta *DocPagesRotate200ResponseMetaCacheDelta + obj := &DocPagesInsertBlank200ResponseMeta{} + var fernTestValueCacheDelta *DocPagesInsertBlank200ResponseMetaCacheDelta obj.SetCacheDelta(fernTestValueCacheDelta) assert.Equal(t, fernTestValueCacheDelta, obj.CacheDelta) assert.NotNil(t, obj.explicitFields) @@ -286336,12 +286870,12 @@ func TestSettersDocPagesRotate200ResponseMeta(t *testing.T) { } -func TestGettersDocPagesRotate200ResponseMeta(t *testing.T) { +func TestGettersDocPagesInsertBlank200ResponseMeta(t *testing.T) { t.Run("GetAffectedPages", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMeta{} - var expected []*DocPagesRotate200ResponseMetaAffectedPagesItem + obj := &DocPagesInsertBlank200ResponseMeta{} + var expected []*DocPagesInsertBlank200ResponseMetaAffectedPagesItem obj.AffectedPages = expected // Act & Assert @@ -286351,7 +286885,7 @@ func TestGettersDocPagesRotate200ResponseMeta(t *testing.T) { t.Run("GetAffectedPages_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMeta{} + obj := &DocPagesInsertBlank200ResponseMeta{} obj.AffectedPages = nil // Act & Assert @@ -286360,7 +286894,7 @@ func TestGettersDocPagesRotate200ResponseMeta(t *testing.T) { t.Run("GetAffectedPages_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMeta + var obj *DocPagesInsertBlank200ResponseMeta // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -286373,8 +286907,8 @@ func TestGettersDocPagesRotate200ResponseMeta(t *testing.T) { t.Run("GetCacheDelta", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMeta{} - var expected *DocPagesRotate200ResponseMetaCacheDelta + obj := &DocPagesInsertBlank200ResponseMeta{} + var expected *DocPagesInsertBlank200ResponseMetaCacheDelta obj.CacheDelta = expected // Act & Assert @@ -286384,7 +286918,7 @@ func TestGettersDocPagesRotate200ResponseMeta(t *testing.T) { t.Run("GetCacheDelta_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMeta{} + obj := &DocPagesInsertBlank200ResponseMeta{} obj.CacheDelta = nil // Act & Assert @@ -286393,7 +286927,7 @@ func TestGettersDocPagesRotate200ResponseMeta(t *testing.T) { t.Run("GetCacheDelta_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMeta + var obj *DocPagesInsertBlank200ResponseMeta // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -286405,12 +286939,12 @@ func TestGettersDocPagesRotate200ResponseMeta(t *testing.T) { } -func TestSettersMarkExplicitDocPagesRotate200ResponseMeta(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsertBlank200ResponseMeta(t *testing.T) { t.Run("SetAffectedPages_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMeta{} - var fernTestValueAffectedPages []*DocPagesRotate200ResponseMetaAffectedPagesItem + obj := &DocPagesInsertBlank200ResponseMeta{} + var fernTestValueAffectedPages []*DocPagesInsertBlank200ResponseMetaAffectedPagesItem // Act obj.SetAffectedPages(fernTestValueAffectedPages) @@ -286440,8 +286974,8 @@ func TestSettersMarkExplicitDocPagesRotate200ResponseMeta(t *testing.T) { t.Run("SetCacheDelta_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMeta{} - var fernTestValueCacheDelta *DocPagesRotate200ResponseMetaCacheDelta + obj := &DocPagesInsertBlank200ResponseMeta{} + var fernTestValueCacheDelta *DocPagesInsertBlank200ResponseMetaCacheDelta // Act obj.SetCacheDelta(fernTestValueCacheDelta) @@ -286470,9 +287004,9 @@ func TestSettersMarkExplicitDocPagesRotate200ResponseMeta(t *testing.T) { } -func TestSettersDocPagesRotate200ResponseMetaAffectedPagesItem(t *testing.T) { +func TestSettersDocPagesInsertBlank200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("SetPageObjectNumber", func(t *testing.T) { - obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItem{} var fernTestValuePageObjectNumber int obj.SetPageObjectNumber(fernTestValuePageObjectNumber) assert.Equal(t, fernTestValuePageObjectNumber, obj.PageObjectNumber) @@ -286480,16 +287014,16 @@ func TestSettersDocPagesRotate200ResponseMetaAffectedPagesItem(t *testing.T) { }) t.Run("SetRevision", func(t *testing.T) { - obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} - var fernTestValueRevision *DocPagesRotate200ResponseMetaAffectedPagesItemRevision + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItem{} + var fernTestValueRevision *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision obj.SetRevision(fernTestValueRevision) assert.Equal(t, fernTestValueRevision, obj.Revision) assert.NotNil(t, obj.explicitFields) }) t.Run("SetWeakAnnotationState", func(t *testing.T) { - obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} - var fernTestValueWeakAnnotationState *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItem{} + var fernTestValueWeakAnnotationState *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState obj.SetWeakAnnotationState(fernTestValueWeakAnnotationState) assert.Equal(t, fernTestValueWeakAnnotationState, obj.WeakAnnotationState) assert.NotNil(t, obj.explicitFields) @@ -286497,11 +287031,11 @@ func TestSettersDocPagesRotate200ResponseMetaAffectedPagesItem(t *testing.T) { } -func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItem(t *testing.T) { +func TestGettersDocPagesInsertBlank200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetPageObjectNumber", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItem{} var expected int obj.PageObjectNumber = expected @@ -286511,7 +287045,7 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetPageObjectNumber_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaAffectedPagesItem + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItem // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -286524,8 +287058,8 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetRevision", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} - var expected *DocPagesRotate200ResponseMetaAffectedPagesItemRevision + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItem{} + var expected *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision obj.Revision = expected // Act & Assert @@ -286535,7 +287069,7 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetRevision_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItem{} obj.Revision = nil // Act & Assert @@ -286544,7 +287078,7 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetRevision_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaAffectedPagesItem + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItem // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -286557,8 +287091,8 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetWeakAnnotationState", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} - var expected *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItem{} + var expected *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState obj.WeakAnnotationState = expected // Act & Assert @@ -286568,7 +287102,7 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetWeakAnnotationState_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItem{} obj.WeakAnnotationState = nil // Act & Assert @@ -286577,7 +287111,7 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetWeakAnnotationState_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaAffectedPagesItem + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItem // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -286589,11 +287123,11 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItem(t *testing.T) { } -func TestSettersMarkExplicitDocPagesRotate200ResponseMetaAffectedPagesItem(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsertBlank200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("SetPageObjectNumber_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItem{} var fernTestValuePageObjectNumber int // Act @@ -286624,8 +287158,8 @@ func TestSettersMarkExplicitDocPagesRotate200ResponseMetaAffectedPagesItem(t *te t.Run("SetRevision_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} - var fernTestValueRevision *DocPagesRotate200ResponseMetaAffectedPagesItemRevision + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItem{} + var fernTestValueRevision *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision // Act obj.SetRevision(fernTestValueRevision) @@ -286655,8 +287189,8 @@ func TestSettersMarkExplicitDocPagesRotate200ResponseMetaAffectedPagesItem(t *te t.Run("SetWeakAnnotationState_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} - var fernTestValueWeakAnnotationState *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItem{} + var fernTestValueWeakAnnotationState *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState // Act obj.SetWeakAnnotationState(fernTestValueWeakAnnotationState) @@ -286685,9 +287219,9 @@ func TestSettersMarkExplicitDocPagesRotate200ResponseMetaAffectedPagesItem(t *te } -func TestSettersDocPagesRotate200ResponseMetaAffectedPagesItemRevision(t *testing.T) { +func TestSettersDocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision(t *testing.T) { t.Run("SetDocSessionID", func(t *testing.T) { - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision{} var fernTestValueDocSessionID string obj.SetDocSessionID(fernTestValueDocSessionID) assert.Equal(t, fernTestValueDocSessionID, obj.DocSessionID) @@ -286695,7 +287229,7 @@ func TestSettersDocPagesRotate200ResponseMetaAffectedPagesItemRevision(t *testin }) t.Run("SetPageObjectNumber", func(t *testing.T) { - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision{} var fernTestValuePageObjectNumber int obj.SetPageObjectNumber(fernTestValuePageObjectNumber) assert.Equal(t, fernTestValuePageObjectNumber, obj.PageObjectNumber) @@ -286703,7 +287237,7 @@ func TestSettersDocPagesRotate200ResponseMetaAffectedPagesItemRevision(t *testin }) t.Run("SetGeneration", func(t *testing.T) { - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision{} var fernTestValueGeneration int obj.SetGeneration(fernTestValueGeneration) assert.Equal(t, fernTestValueGeneration, obj.Generation) @@ -286712,11 +287246,11 @@ func TestSettersDocPagesRotate200ResponseMetaAffectedPagesItemRevision(t *testin } -func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemRevision(t *testing.T) { +func TestGettersDocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision(t *testing.T) { t.Run("GetDocSessionID", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision{} var expected string obj.DocSessionID = expected @@ -286726,7 +287260,7 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemRevision(t *testin t.Run("GetDocSessionID_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaAffectedPagesItemRevision + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -286739,7 +287273,7 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemRevision(t *testin t.Run("GetPageObjectNumber", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision{} var expected int obj.PageObjectNumber = expected @@ -286749,7 +287283,7 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemRevision(t *testin t.Run("GetPageObjectNumber_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaAffectedPagesItemRevision + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -286762,7 +287296,7 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemRevision(t *testin t.Run("GetGeneration", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision{} var expected int obj.Generation = expected @@ -286772,7 +287306,7 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemRevision(t *testin t.Run("GetGeneration_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaAffectedPagesItemRevision + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -286784,11 +287318,11 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemRevision(t *testin } -func TestSettersMarkExplicitDocPagesRotate200ResponseMetaAffectedPagesItemRevision(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision(t *testing.T) { t.Run("SetDocSessionID_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision{} var fernTestValueDocSessionID string // Act @@ -286819,7 +287353,7 @@ func TestSettersMarkExplicitDocPagesRotate200ResponseMetaAffectedPagesItemRevisi t.Run("SetPageObjectNumber_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision{} var fernTestValuePageObjectNumber int // Act @@ -286850,7 +287384,7 @@ func TestSettersMarkExplicitDocPagesRotate200ResponseMetaAffectedPagesItemRevisi t.Run("SetGeneration_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision{} var fernTestValueGeneration int // Act @@ -286880,11 +287414,11 @@ func TestSettersMarkExplicitDocPagesRotate200ResponseMetaAffectedPagesItemRevisi } -func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState(t *testing.T) { +func TestGettersDocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState(t *testing.T) { t.Run("GetKind", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState{} var expected string obj.Kind = expected @@ -286894,7 +287428,7 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStat t.Run("GetKind_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -286907,8 +287441,8 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStat t.Run("GetUnknown", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState{} - var expected *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState{} + var expected *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown obj.Unknown = expected // Act & Assert @@ -286918,7 +287452,7 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStat t.Run("GetUnknown_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState{} obj.Unknown = nil // Act & Assert @@ -286927,7 +287461,7 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStat t.Run("GetUnknown_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -286940,8 +287474,8 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStat t.Run("GetKnown", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState{} - var expected *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState{} + var expected *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown obj.Known = expected // Act & Assert @@ -286951,7 +287485,7 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStat t.Run("GetKnown_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState{} obj.Known = nil // Act & Assert @@ -286960,7 +287494,7 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStat t.Run("GetKnown_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationState // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -286972,9 +287506,9 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStat } -func TestSettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { +func TestSettersDocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { t.Run("SetHasAnyWeakAnnotations", func(t *testing.T) { - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} var fernTestValueHasAnyWeakAnnotations bool obj.SetHasAnyWeakAnnotations(fernTestValueHasAnyWeakAnnotations) assert.Equal(t, fernTestValueHasAnyWeakAnnotations, obj.HasAnyWeakAnnotations) @@ -286983,11 +287517,11 @@ func TestSettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStat } -func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { +func TestGettersDocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { t.Run("GetHasAnyWeakAnnotations", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} var expected bool obj.HasAnyWeakAnnotations = expected @@ -286997,7 +287531,7 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStat t.Run("GetHasAnyWeakAnnotations_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -287009,11 +287543,11 @@ func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStat } -func TestSettersMarkExplicitDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { t.Run("SetHasAnyWeakAnnotations_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} var fernTestValueHasAnyWeakAnnotations bool // Act @@ -287043,9 +287577,9 @@ func TestSettersMarkExplicitDocPagesRotate200ResponseMetaAffectedPagesItemWeakAn } -func TestSettersDocPagesRotate200ResponseMetaCacheDelta(t *testing.T) { +func TestSettersDocPagesInsertBlank200ResponseMetaCacheDelta(t *testing.T) { t.Run("SetPreviousDocVersion", func(t *testing.T) { - obj := &DocPagesRotate200ResponseMetaCacheDelta{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDelta{} var fernTestValuePreviousDocVersion int obj.SetPreviousDocVersion(fernTestValuePreviousDocVersion) assert.Equal(t, fernTestValuePreviousDocVersion, obj.PreviousDocVersion) @@ -287053,7 +287587,7 @@ func TestSettersDocPagesRotate200ResponseMetaCacheDelta(t *testing.T) { }) t.Run("SetDocVersion", func(t *testing.T) { - obj := &DocPagesRotate200ResponseMetaCacheDelta{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDelta{} var fernTestValueDocVersion int obj.SetDocVersion(fernTestValueDocVersion) assert.Equal(t, fernTestValueDocVersion, obj.DocVersion) @@ -287061,8 +287595,8 @@ func TestSettersDocPagesRotate200ResponseMetaCacheDelta(t *testing.T) { }) t.Run("SetPages", func(t *testing.T) { - obj := &DocPagesRotate200ResponseMetaCacheDelta{} - var fernTestValuePages []*DocPagesRotate200ResponseMetaCacheDeltaPagesItem + obj := &DocPagesInsertBlank200ResponseMetaCacheDelta{} + var fernTestValuePages []*DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem obj.SetPages(fernTestValuePages) assert.Equal(t, fernTestValuePages, obj.Pages) assert.NotNil(t, obj.explicitFields) @@ -287070,11 +287604,11 @@ func TestSettersDocPagesRotate200ResponseMetaCacheDelta(t *testing.T) { } -func TestGettersDocPagesRotate200ResponseMetaCacheDelta(t *testing.T) { +func TestGettersDocPagesInsertBlank200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetPreviousDocVersion", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaCacheDelta{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDelta{} var expected int obj.PreviousDocVersion = expected @@ -287084,7 +287618,7 @@ func TestGettersDocPagesRotate200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetPreviousDocVersion_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaCacheDelta + var obj *DocPagesInsertBlank200ResponseMetaCacheDelta // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -287097,7 +287631,7 @@ func TestGettersDocPagesRotate200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetDocVersion", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaCacheDelta{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDelta{} var expected int obj.DocVersion = expected @@ -287107,7 +287641,7 @@ func TestGettersDocPagesRotate200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetDocVersion_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaCacheDelta + var obj *DocPagesInsertBlank200ResponseMetaCacheDelta // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -287120,8 +287654,8 @@ func TestGettersDocPagesRotate200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetPages", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaCacheDelta{} - var expected []*DocPagesRotate200ResponseMetaCacheDeltaPagesItem + obj := &DocPagesInsertBlank200ResponseMetaCacheDelta{} + var expected []*DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem obj.Pages = expected // Act & Assert @@ -287131,7 +287665,7 @@ func TestGettersDocPagesRotate200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetPages_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaCacheDelta{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDelta{} obj.Pages = nil // Act & Assert @@ -287140,7 +287674,7 @@ func TestGettersDocPagesRotate200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetPages_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaCacheDelta + var obj *DocPagesInsertBlank200ResponseMetaCacheDelta // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -287152,11 +287686,11 @@ func TestGettersDocPagesRotate200ResponseMetaCacheDelta(t *testing.T) { } -func TestSettersMarkExplicitDocPagesRotate200ResponseMetaCacheDelta(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsertBlank200ResponseMetaCacheDelta(t *testing.T) { t.Run("SetPreviousDocVersion_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaCacheDelta{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDelta{} var fernTestValuePreviousDocVersion int // Act @@ -287187,7 +287721,7 @@ func TestSettersMarkExplicitDocPagesRotate200ResponseMetaCacheDelta(t *testing.T t.Run("SetDocVersion_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaCacheDelta{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDelta{} var fernTestValueDocVersion int // Act @@ -287218,8 +287752,8 @@ func TestSettersMarkExplicitDocPagesRotate200ResponseMetaCacheDelta(t *testing.T t.Run("SetPages_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaCacheDelta{} - var fernTestValuePages []*DocPagesRotate200ResponseMetaCacheDeltaPagesItem + obj := &DocPagesInsertBlank200ResponseMetaCacheDelta{} + var fernTestValuePages []*DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem // Act obj.SetPages(fernTestValuePages) @@ -287248,9 +287782,9 @@ func TestSettersMarkExplicitDocPagesRotate200ResponseMetaCacheDelta(t *testing.T } -func TestSettersDocPagesRotate200ResponseMetaCacheDeltaPagesItem(t *testing.T) { +func TestSettersDocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("SetPageObjectNumber", func(t *testing.T) { - obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItem{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem{} var fernTestValuePageObjectNumber int obj.SetPageObjectNumber(fernTestValuePageObjectNumber) assert.Equal(t, fernTestValuePageObjectNumber, obj.PageObjectNumber) @@ -287258,8 +287792,8 @@ func TestSettersDocPagesRotate200ResponseMetaCacheDeltaPagesItem(t *testing.T) { }) t.Run("SetCache", func(t *testing.T) { - obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItem{} - var fernTestValueCache *DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem{} + var fernTestValueCache *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache obj.SetCache(fernTestValueCache) assert.Equal(t, fernTestValueCache, obj.Cache) assert.NotNil(t, obj.explicitFields) @@ -287267,11 +287801,11 @@ func TestSettersDocPagesRotate200ResponseMetaCacheDeltaPagesItem(t *testing.T) { } -func TestGettersDocPagesRotate200ResponseMetaCacheDeltaPagesItem(t *testing.T) { +func TestGettersDocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("GetPageObjectNumber", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItem{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem{} var expected int obj.PageObjectNumber = expected @@ -287281,7 +287815,7 @@ func TestGettersDocPagesRotate200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("GetPageObjectNumber_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaCacheDeltaPagesItem + var obj *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -287294,8 +287828,8 @@ func TestGettersDocPagesRotate200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("GetCache", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItem{} - var expected *DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem{} + var expected *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache obj.Cache = expected // Act & Assert @@ -287305,7 +287839,7 @@ func TestGettersDocPagesRotate200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("GetCache_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItem{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem{} obj.Cache = nil // Act & Assert @@ -287314,7 +287848,7 @@ func TestGettersDocPagesRotate200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("GetCache_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaCacheDeltaPagesItem + var obj *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -287326,11 +287860,11 @@ func TestGettersDocPagesRotate200ResponseMetaCacheDeltaPagesItem(t *testing.T) { } -func TestSettersMarkExplicitDocPagesRotate200ResponseMetaCacheDeltaPagesItem(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("SetPageObjectNumber_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItem{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem{} var fernTestValuePageObjectNumber int // Act @@ -287361,8 +287895,8 @@ func TestSettersMarkExplicitDocPagesRotate200ResponseMetaCacheDeltaPagesItem(t * t.Run("SetCache_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItem{} - var fernTestValueCache *DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem{} + var fernTestValueCache *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache // Act obj.SetCache(fernTestValueCache) @@ -287391,9 +287925,9 @@ func TestSettersMarkExplicitDocPagesRotate200ResponseMetaCacheDeltaPagesItem(t * } -func TestSettersDocPagesRotate200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { +func TestSettersDocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { t.Run("SetContentVersion", func(t *testing.T) { - obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache{} var fernTestValueContentVersion int obj.SetContentVersion(fernTestValueContentVersion) assert.Equal(t, fernTestValueContentVersion, obj.ContentVersion) @@ -287401,7 +287935,7 @@ func TestSettersDocPagesRotate200ResponseMetaCacheDeltaPagesItemCache(t *testing }) t.Run("SetAnnotationVersion", func(t *testing.T) { - obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache{} var fernTestValueAnnotationVersion int obj.SetAnnotationVersion(fernTestValueAnnotationVersion) assert.Equal(t, fernTestValueAnnotationVersion, obj.AnnotationVersion) @@ -287410,11 +287944,11 @@ func TestSettersDocPagesRotate200ResponseMetaCacheDeltaPagesItemCache(t *testing } -func TestGettersDocPagesRotate200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { +func TestGettersDocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { t.Run("GetContentVersion", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache{} var expected int obj.ContentVersion = expected @@ -287424,7 +287958,7 @@ func TestGettersDocPagesRotate200ResponseMetaCacheDeltaPagesItemCache(t *testing t.Run("GetContentVersion_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache + var obj *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -287437,7 +287971,7 @@ func TestGettersDocPagesRotate200ResponseMetaCacheDeltaPagesItemCache(t *testing t.Run("GetAnnotationVersion", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache{} var expected int obj.AnnotationVersion = expected @@ -287447,7 +287981,7 @@ func TestGettersDocPagesRotate200ResponseMetaCacheDeltaPagesItemCache(t *testing t.Run("GetAnnotationVersion_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache + var obj *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -287459,11 +287993,11 @@ func TestGettersDocPagesRotate200ResponseMetaCacheDeltaPagesItemCache(t *testing } -func TestSettersMarkExplicitDocPagesRotate200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { t.Run("SetContentVersion_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache{} var fernTestValueContentVersion int // Act @@ -287494,7 +288028,7 @@ func TestSettersMarkExplicitDocPagesRotate200ResponseMetaCacheDeltaPagesItemCach t.Run("SetAnnotationVersion_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache{} var fernTestValueAnnotationVersion int // Act @@ -287524,25 +288058,25 @@ func TestSettersMarkExplicitDocPagesRotate200ResponseMetaCacheDeltaPagesItemCach } -func TestSettersDocPagesRotate400Response(t *testing.T) { +func TestSettersDocPagesInsertBlank400Response(t *testing.T) { t.Run("SetName", func(t *testing.T) { - obj := &DocPagesRotate400Response{} - var fernTestValueName DocPagesRotate400ResponseName + obj := &DocPagesInsertBlank400Response{} + var fernTestValueName DocPagesInsertBlank400ResponseName obj.SetName(fernTestValueName) assert.Equal(t, fernTestValueName, obj.Name) assert.NotNil(t, obj.explicitFields) }) t.Run("SetCode", func(t *testing.T) { - obj := &DocPagesRotate400Response{} - var fernTestValueCode DocPagesRotate400ResponseCode + obj := &DocPagesInsertBlank400Response{} + var fernTestValueCode DocPagesInsertBlank400ResponseCode obj.SetCode(fernTestValueCode) assert.Equal(t, fernTestValueCode, obj.Code) assert.NotNil(t, obj.explicitFields) }) t.Run("SetMessage", func(t *testing.T) { - obj := &DocPagesRotate400Response{} + obj := &DocPagesInsertBlank400Response{} var fernTestValueMessage string obj.SetMessage(fernTestValueMessage) assert.Equal(t, fernTestValueMessage, obj.Message) @@ -287550,7 +288084,7 @@ func TestSettersDocPagesRotate400Response(t *testing.T) { }) t.Run("SetDetails", func(t *testing.T) { - obj := &DocPagesRotate400Response{} + obj := &DocPagesInsertBlank400Response{} var fernTestValueDetails map[string]any obj.SetDetails(fernTestValueDetails) assert.Equal(t, fernTestValueDetails, obj.Details) @@ -287559,12 +288093,12 @@ func TestSettersDocPagesRotate400Response(t *testing.T) { } -func TestGettersDocPagesRotate400Response(t *testing.T) { +func TestGettersDocPagesInsertBlank400Response(t *testing.T) { t.Run("GetName", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate400Response{} - var expected DocPagesRotate400ResponseName + obj := &DocPagesInsertBlank400Response{} + var expected DocPagesInsertBlank400ResponseName obj.Name = expected // Act & Assert @@ -287573,7 +288107,7 @@ func TestGettersDocPagesRotate400Response(t *testing.T) { t.Run("GetName_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate400Response + var obj *DocPagesInsertBlank400Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -287586,8 +288120,8 @@ func TestGettersDocPagesRotate400Response(t *testing.T) { t.Run("GetCode", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate400Response{} - var expected DocPagesRotate400ResponseCode + obj := &DocPagesInsertBlank400Response{} + var expected DocPagesInsertBlank400ResponseCode obj.Code = expected // Act & Assert @@ -287596,7 +288130,7 @@ func TestGettersDocPagesRotate400Response(t *testing.T) { t.Run("GetCode_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate400Response + var obj *DocPagesInsertBlank400Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -287609,7 +288143,7 @@ func TestGettersDocPagesRotate400Response(t *testing.T) { t.Run("GetMessage", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate400Response{} + obj := &DocPagesInsertBlank400Response{} var expected string obj.Message = expected @@ -287619,7 +288153,7 @@ func TestGettersDocPagesRotate400Response(t *testing.T) { t.Run("GetMessage_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate400Response + var obj *DocPagesInsertBlank400Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -287632,7 +288166,7 @@ func TestGettersDocPagesRotate400Response(t *testing.T) { t.Run("GetDetails", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate400Response{} + obj := &DocPagesInsertBlank400Response{} var expected map[string]any obj.Details = expected @@ -287643,7 +288177,7 @@ func TestGettersDocPagesRotate400Response(t *testing.T) { t.Run("GetDetails_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate400Response{} + obj := &DocPagesInsertBlank400Response{} obj.Details = nil // Act & Assert @@ -287652,7 +288186,7 @@ func TestGettersDocPagesRotate400Response(t *testing.T) { t.Run("GetDetails_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate400Response + var obj *DocPagesInsertBlank400Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -287664,12 +288198,12 @@ func TestGettersDocPagesRotate400Response(t *testing.T) { } -func TestSettersMarkExplicitDocPagesRotate400Response(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsertBlank400Response(t *testing.T) { t.Run("SetName_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate400Response{} - var fernTestValueName DocPagesRotate400ResponseName + obj := &DocPagesInsertBlank400Response{} + var fernTestValueName DocPagesInsertBlank400ResponseName // Act obj.SetName(fernTestValueName) @@ -287699,8 +288233,8 @@ func TestSettersMarkExplicitDocPagesRotate400Response(t *testing.T) { t.Run("SetCode_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate400Response{} - var fernTestValueCode DocPagesRotate400ResponseCode + obj := &DocPagesInsertBlank400Response{} + var fernTestValueCode DocPagesInsertBlank400ResponseCode // Act obj.SetCode(fernTestValueCode) @@ -287730,7 +288264,7 @@ func TestSettersMarkExplicitDocPagesRotate400Response(t *testing.T) { t.Run("SetMessage_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate400Response{} + obj := &DocPagesInsertBlank400Response{} var fernTestValueMessage string // Act @@ -287761,7 +288295,7 @@ func TestSettersMarkExplicitDocPagesRotate400Response(t *testing.T) { t.Run("SetDetails_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate400Response{} + obj := &DocPagesInsertBlank400Response{} var fernTestValueDetails map[string]any // Act @@ -287791,25 +288325,25 @@ func TestSettersMarkExplicitDocPagesRotate400Response(t *testing.T) { } -func TestSettersDocPagesRotate404Response(t *testing.T) { +func TestSettersDocPagesInsertBlank404Response(t *testing.T) { t.Run("SetName", func(t *testing.T) { - obj := &DocPagesRotate404Response{} - var fernTestValueName DocPagesRotate404ResponseName + obj := &DocPagesInsertBlank404Response{} + var fernTestValueName DocPagesInsertBlank404ResponseName obj.SetName(fernTestValueName) assert.Equal(t, fernTestValueName, obj.Name) assert.NotNil(t, obj.explicitFields) }) t.Run("SetCode", func(t *testing.T) { - obj := &DocPagesRotate404Response{} - var fernTestValueCode DocPagesRotate404ResponseCode + obj := &DocPagesInsertBlank404Response{} + var fernTestValueCode DocPagesInsertBlank404ResponseCode obj.SetCode(fernTestValueCode) assert.Equal(t, fernTestValueCode, obj.Code) assert.NotNil(t, obj.explicitFields) }) t.Run("SetMessage", func(t *testing.T) { - obj := &DocPagesRotate404Response{} + obj := &DocPagesInsertBlank404Response{} var fernTestValueMessage string obj.SetMessage(fernTestValueMessage) assert.Equal(t, fernTestValueMessage, obj.Message) @@ -287817,7 +288351,7 @@ func TestSettersDocPagesRotate404Response(t *testing.T) { }) t.Run("SetDetails", func(t *testing.T) { - obj := &DocPagesRotate404Response{} + obj := &DocPagesInsertBlank404Response{} var fernTestValueDetails map[string]any obj.SetDetails(fernTestValueDetails) assert.Equal(t, fernTestValueDetails, obj.Details) @@ -287826,12 +288360,12 @@ func TestSettersDocPagesRotate404Response(t *testing.T) { } -func TestGettersDocPagesRotate404Response(t *testing.T) { +func TestGettersDocPagesInsertBlank404Response(t *testing.T) { t.Run("GetName", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate404Response{} - var expected DocPagesRotate404ResponseName + obj := &DocPagesInsertBlank404Response{} + var expected DocPagesInsertBlank404ResponseName obj.Name = expected // Act & Assert @@ -287840,7 +288374,7 @@ func TestGettersDocPagesRotate404Response(t *testing.T) { t.Run("GetName_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate404Response + var obj *DocPagesInsertBlank404Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -287853,8 +288387,8 @@ func TestGettersDocPagesRotate404Response(t *testing.T) { t.Run("GetCode", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate404Response{} - var expected DocPagesRotate404ResponseCode + obj := &DocPagesInsertBlank404Response{} + var expected DocPagesInsertBlank404ResponseCode obj.Code = expected // Act & Assert @@ -287863,7 +288397,7 @@ func TestGettersDocPagesRotate404Response(t *testing.T) { t.Run("GetCode_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate404Response + var obj *DocPagesInsertBlank404Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -287876,7 +288410,7 @@ func TestGettersDocPagesRotate404Response(t *testing.T) { t.Run("GetMessage", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate404Response{} + obj := &DocPagesInsertBlank404Response{} var expected string obj.Message = expected @@ -287886,7 +288420,7 @@ func TestGettersDocPagesRotate404Response(t *testing.T) { t.Run("GetMessage_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate404Response + var obj *DocPagesInsertBlank404Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -287899,7 +288433,7 @@ func TestGettersDocPagesRotate404Response(t *testing.T) { t.Run("GetDetails", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate404Response{} + obj := &DocPagesInsertBlank404Response{} var expected map[string]any obj.Details = expected @@ -287910,7 +288444,7 @@ func TestGettersDocPagesRotate404Response(t *testing.T) { t.Run("GetDetails_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate404Response{} + obj := &DocPagesInsertBlank404Response{} obj.Details = nil // Act & Assert @@ -287919,7 +288453,7 @@ func TestGettersDocPagesRotate404Response(t *testing.T) { t.Run("GetDetails_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocPagesRotate404Response + var obj *DocPagesInsertBlank404Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -287931,12 +288465,12 @@ func TestGettersDocPagesRotate404Response(t *testing.T) { } -func TestSettersMarkExplicitDocPagesRotate404Response(t *testing.T) { +func TestSettersMarkExplicitDocPagesInsertBlank404Response(t *testing.T) { t.Run("SetName_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate404Response{} - var fernTestValueName DocPagesRotate404ResponseName + obj := &DocPagesInsertBlank404Response{} + var fernTestValueName DocPagesInsertBlank404ResponseName // Act obj.SetName(fernTestValueName) @@ -287966,8 +288500,8 @@ func TestSettersMarkExplicitDocPagesRotate404Response(t *testing.T) { t.Run("SetCode_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate404Response{} - var fernTestValueCode DocPagesRotate404ResponseCode + obj := &DocPagesInsertBlank404Response{} + var fernTestValueCode DocPagesInsertBlank404ResponseCode // Act obj.SetCode(fernTestValueCode) @@ -287997,7 +288531,7 @@ func TestSettersMarkExplicitDocPagesRotate404Response(t *testing.T) { t.Run("SetMessage_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate404Response{} + obj := &DocPagesInsertBlank404Response{} var fernTestValueMessage string // Act @@ -288028,7 +288562,7 @@ func TestSettersMarkExplicitDocPagesRotate404Response(t *testing.T) { t.Run("SetDetails_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocPagesRotate404Response{} + obj := &DocPagesInsertBlank404Response{} var fernTestValueDetails map[string]any // Act @@ -288058,10 +288592,10 @@ func TestSettersMarkExplicitDocPagesRotate404Response(t *testing.T) { } -func TestSettersDocRedactionsApply200Response(t *testing.T) { +func TestSettersDocPagesMove200Response(t *testing.T) { t.Run("SetMeta", func(t *testing.T) { - obj := &DocRedactionsApply200Response{} - var fernTestValueMeta *DocRedactionsApply200ResponseMeta + obj := &DocPagesMove200Response{} + var fernTestValueMeta *DocPagesMove200ResponseMeta obj.SetMeta(fernTestValueMeta) assert.Equal(t, fernTestValueMeta, obj.Meta) assert.NotNil(t, obj.explicitFields) @@ -288069,12 +288603,12 @@ func TestSettersDocRedactionsApply200Response(t *testing.T) { } -func TestGettersDocRedactionsApply200Response(t *testing.T) { +func TestGettersDocPagesMove200Response(t *testing.T) { t.Run("GetMeta", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200Response{} - var expected *DocRedactionsApply200ResponseMeta + obj := &DocPagesMove200Response{} + var expected *DocPagesMove200ResponseMeta obj.Meta = expected // Act & Assert @@ -288084,7 +288618,7 @@ func TestGettersDocRedactionsApply200Response(t *testing.T) { t.Run("GetMeta_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200Response{} + obj := &DocPagesMove200Response{} obj.Meta = nil // Act & Assert @@ -288093,7 +288627,7 @@ func TestGettersDocRedactionsApply200Response(t *testing.T) { t.Run("GetMeta_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200Response + var obj *DocPagesMove200Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -288105,12 +288639,12 @@ func TestGettersDocRedactionsApply200Response(t *testing.T) { } -func TestSettersMarkExplicitDocRedactionsApply200Response(t *testing.T) { +func TestSettersMarkExplicitDocPagesMove200Response(t *testing.T) { t.Run("SetMeta_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200Response{} - var fernTestValueMeta *DocRedactionsApply200ResponseMeta + obj := &DocPagesMove200Response{} + var fernTestValueMeta *DocPagesMove200ResponseMeta // Act obj.SetMeta(fernTestValueMeta) @@ -288139,18 +288673,18 @@ func TestSettersMarkExplicitDocRedactionsApply200Response(t *testing.T) { } -func TestSettersDocRedactionsApply200ResponseMeta(t *testing.T) { +func TestSettersDocPagesMove200ResponseMeta(t *testing.T) { t.Run("SetAffectedPages", func(t *testing.T) { - obj := &DocRedactionsApply200ResponseMeta{} - var fernTestValueAffectedPages []*DocRedactionsApply200ResponseMetaAffectedPagesItem + obj := &DocPagesMove200ResponseMeta{} + var fernTestValueAffectedPages []*DocPagesMove200ResponseMetaAffectedPagesItem obj.SetAffectedPages(fernTestValueAffectedPages) assert.Equal(t, fernTestValueAffectedPages, obj.AffectedPages) assert.NotNil(t, obj.explicitFields) }) t.Run("SetCacheDelta", func(t *testing.T) { - obj := &DocRedactionsApply200ResponseMeta{} - var fernTestValueCacheDelta *DocRedactionsApply200ResponseMetaCacheDelta + obj := &DocPagesMove200ResponseMeta{} + var fernTestValueCacheDelta *DocPagesMove200ResponseMetaCacheDelta obj.SetCacheDelta(fernTestValueCacheDelta) assert.Equal(t, fernTestValueCacheDelta, obj.CacheDelta) assert.NotNil(t, obj.explicitFields) @@ -288158,12 +288692,12 @@ func TestSettersDocRedactionsApply200ResponseMeta(t *testing.T) { } -func TestGettersDocRedactionsApply200ResponseMeta(t *testing.T) { +func TestGettersDocPagesMove200ResponseMeta(t *testing.T) { t.Run("GetAffectedPages", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMeta{} - var expected []*DocRedactionsApply200ResponseMetaAffectedPagesItem + obj := &DocPagesMove200ResponseMeta{} + var expected []*DocPagesMove200ResponseMetaAffectedPagesItem obj.AffectedPages = expected // Act & Assert @@ -288173,7 +288707,7 @@ func TestGettersDocRedactionsApply200ResponseMeta(t *testing.T) { t.Run("GetAffectedPages_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMeta{} + obj := &DocPagesMove200ResponseMeta{} obj.AffectedPages = nil // Act & Assert @@ -288182,7 +288716,7 @@ func TestGettersDocRedactionsApply200ResponseMeta(t *testing.T) { t.Run("GetAffectedPages_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMeta + var obj *DocPagesMove200ResponseMeta // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -288195,8 +288729,8 @@ func TestGettersDocRedactionsApply200ResponseMeta(t *testing.T) { t.Run("GetCacheDelta", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMeta{} - var expected *DocRedactionsApply200ResponseMetaCacheDelta + obj := &DocPagesMove200ResponseMeta{} + var expected *DocPagesMove200ResponseMetaCacheDelta obj.CacheDelta = expected // Act & Assert @@ -288206,7 +288740,7 @@ func TestGettersDocRedactionsApply200ResponseMeta(t *testing.T) { t.Run("GetCacheDelta_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMeta{} + obj := &DocPagesMove200ResponseMeta{} obj.CacheDelta = nil // Act & Assert @@ -288215,7 +288749,7 @@ func TestGettersDocRedactionsApply200ResponseMeta(t *testing.T) { t.Run("GetCacheDelta_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMeta + var obj *DocPagesMove200ResponseMeta // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -288227,12 +288761,12 @@ func TestGettersDocRedactionsApply200ResponseMeta(t *testing.T) { } -func TestSettersMarkExplicitDocRedactionsApply200ResponseMeta(t *testing.T) { +func TestSettersMarkExplicitDocPagesMove200ResponseMeta(t *testing.T) { t.Run("SetAffectedPages_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMeta{} - var fernTestValueAffectedPages []*DocRedactionsApply200ResponseMetaAffectedPagesItem + obj := &DocPagesMove200ResponseMeta{} + var fernTestValueAffectedPages []*DocPagesMove200ResponseMetaAffectedPagesItem // Act obj.SetAffectedPages(fernTestValueAffectedPages) @@ -288262,8 +288796,8 @@ func TestSettersMarkExplicitDocRedactionsApply200ResponseMeta(t *testing.T) { t.Run("SetCacheDelta_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMeta{} - var fernTestValueCacheDelta *DocRedactionsApply200ResponseMetaCacheDelta + obj := &DocPagesMove200ResponseMeta{} + var fernTestValueCacheDelta *DocPagesMove200ResponseMetaCacheDelta // Act obj.SetCacheDelta(fernTestValueCacheDelta) @@ -288292,9 +288826,9 @@ func TestSettersMarkExplicitDocRedactionsApply200ResponseMeta(t *testing.T) { } -func TestSettersDocRedactionsApply200ResponseMetaAffectedPagesItem(t *testing.T) { +func TestSettersDocPagesMove200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("SetPageObjectNumber", func(t *testing.T) { - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} var fernTestValuePageObjectNumber int obj.SetPageObjectNumber(fernTestValuePageObjectNumber) assert.Equal(t, fernTestValuePageObjectNumber, obj.PageObjectNumber) @@ -288302,16 +288836,16 @@ func TestSettersDocRedactionsApply200ResponseMetaAffectedPagesItem(t *testing.T) }) t.Run("SetRevision", func(t *testing.T) { - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} - var fernTestValueRevision *DocRedactionsApply200ResponseMetaAffectedPagesItemRevision + obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} + var fernTestValueRevision *DocPagesMove200ResponseMetaAffectedPagesItemRevision obj.SetRevision(fernTestValueRevision) assert.Equal(t, fernTestValueRevision, obj.Revision) assert.NotNil(t, obj.explicitFields) }) t.Run("SetWeakAnnotationState", func(t *testing.T) { - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} - var fernTestValueWeakAnnotationState *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState + obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} + var fernTestValueWeakAnnotationState *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState obj.SetWeakAnnotationState(fernTestValueWeakAnnotationState) assert.Equal(t, fernTestValueWeakAnnotationState, obj.WeakAnnotationState) assert.NotNil(t, obj.explicitFields) @@ -288319,11 +288853,11 @@ func TestSettersDocRedactionsApply200ResponseMetaAffectedPagesItem(t *testing.T) } -func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItem(t *testing.T) { +func TestGettersDocPagesMove200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("GetPageObjectNumber", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} var expected int obj.PageObjectNumber = expected @@ -288333,7 +288867,7 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItem(t *testing.T) t.Run("GetPageObjectNumber_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaAffectedPagesItem + var obj *DocPagesMove200ResponseMetaAffectedPagesItem // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -288346,8 +288880,8 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItem(t *testing.T) t.Run("GetRevision", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} - var expected *DocRedactionsApply200ResponseMetaAffectedPagesItemRevision + obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} + var expected *DocPagesMove200ResponseMetaAffectedPagesItemRevision obj.Revision = expected // Act & Assert @@ -288357,7 +288891,7 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItem(t *testing.T) t.Run("GetRevision_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} obj.Revision = nil // Act & Assert @@ -288366,7 +288900,7 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItem(t *testing.T) t.Run("GetRevision_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaAffectedPagesItem + var obj *DocPagesMove200ResponseMetaAffectedPagesItem // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -288379,8 +288913,8 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItem(t *testing.T) t.Run("GetWeakAnnotationState", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} - var expected *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState + obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} + var expected *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState obj.WeakAnnotationState = expected // Act & Assert @@ -288390,7 +288924,7 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItem(t *testing.T) t.Run("GetWeakAnnotationState_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} obj.WeakAnnotationState = nil // Act & Assert @@ -288399,7 +288933,7 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItem(t *testing.T) t.Run("GetWeakAnnotationState_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaAffectedPagesItem + var obj *DocPagesMove200ResponseMetaAffectedPagesItem // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -288411,11 +288945,11 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItem(t *testing.T) } -func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaAffectedPagesItem(t *testing.T) { +func TestSettersMarkExplicitDocPagesMove200ResponseMetaAffectedPagesItem(t *testing.T) { t.Run("SetPageObjectNumber_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} var fernTestValuePageObjectNumber int // Act @@ -288446,8 +288980,8 @@ func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaAffectedPagesItem(t t.Run("SetRevision_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} - var fernTestValueRevision *DocRedactionsApply200ResponseMetaAffectedPagesItemRevision + obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} + var fernTestValueRevision *DocPagesMove200ResponseMetaAffectedPagesItemRevision // Act obj.SetRevision(fernTestValueRevision) @@ -288477,8 +289011,8 @@ func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaAffectedPagesItem(t t.Run("SetWeakAnnotationState_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} - var fernTestValueWeakAnnotationState *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState + obj := &DocPagesMove200ResponseMetaAffectedPagesItem{} + var fernTestValueWeakAnnotationState *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState // Act obj.SetWeakAnnotationState(fernTestValueWeakAnnotationState) @@ -288507,9 +289041,9 @@ func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaAffectedPagesItem(t } -func TestSettersDocRedactionsApply200ResponseMetaAffectedPagesItemRevision(t *testing.T) { +func TestSettersDocPagesMove200ResponseMetaAffectedPagesItemRevision(t *testing.T) { t.Run("SetDocSessionID", func(t *testing.T) { - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} var fernTestValueDocSessionID string obj.SetDocSessionID(fernTestValueDocSessionID) assert.Equal(t, fernTestValueDocSessionID, obj.DocSessionID) @@ -288517,7 +289051,7 @@ func TestSettersDocRedactionsApply200ResponseMetaAffectedPagesItemRevision(t *te }) t.Run("SetPageObjectNumber", func(t *testing.T) { - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} var fernTestValuePageObjectNumber int obj.SetPageObjectNumber(fernTestValuePageObjectNumber) assert.Equal(t, fernTestValuePageObjectNumber, obj.PageObjectNumber) @@ -288525,7 +289059,7 @@ func TestSettersDocRedactionsApply200ResponseMetaAffectedPagesItemRevision(t *te }) t.Run("SetGeneration", func(t *testing.T) { - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} var fernTestValueGeneration int obj.SetGeneration(fernTestValueGeneration) assert.Equal(t, fernTestValueGeneration, obj.Generation) @@ -288534,11 +289068,11 @@ func TestSettersDocRedactionsApply200ResponseMetaAffectedPagesItemRevision(t *te } -func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemRevision(t *testing.T) { +func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemRevision(t *testing.T) { t.Run("GetDocSessionID", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} var expected string obj.DocSessionID = expected @@ -288548,7 +289082,7 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemRevision(t *te t.Run("GetDocSessionID_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaAffectedPagesItemRevision + var obj *DocPagesMove200ResponseMetaAffectedPagesItemRevision // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -288561,7 +289095,7 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemRevision(t *te t.Run("GetPageObjectNumber", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} var expected int obj.PageObjectNumber = expected @@ -288571,7 +289105,7 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemRevision(t *te t.Run("GetPageObjectNumber_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaAffectedPagesItemRevision + var obj *DocPagesMove200ResponseMetaAffectedPagesItemRevision // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -288584,7 +289118,7 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemRevision(t *te t.Run("GetGeneration", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} var expected int obj.Generation = expected @@ -288594,7 +289128,7 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemRevision(t *te t.Run("GetGeneration_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaAffectedPagesItemRevision + var obj *DocPagesMove200ResponseMetaAffectedPagesItemRevision // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -288606,11 +289140,11 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemRevision(t *te } -func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaAffectedPagesItemRevision(t *testing.T) { +func TestSettersMarkExplicitDocPagesMove200ResponseMetaAffectedPagesItemRevision(t *testing.T) { t.Run("SetDocSessionID_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} var fernTestValueDocSessionID string // Act @@ -288641,7 +289175,7 @@ func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaAffectedPagesItemRe t.Run("SetPageObjectNumber_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} var fernTestValuePageObjectNumber int // Act @@ -288672,7 +289206,7 @@ func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaAffectedPagesItemRe t.Run("SetGeneration_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItemRevision{} var fernTestValueGeneration int // Act @@ -288702,11 +289236,11 @@ func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaAffectedPagesItemRe } -func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState(t *testing.T) { +func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState(t *testing.T) { t.Run("GetKind", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState{} var expected string obj.Kind = expected @@ -288716,7 +289250,7 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotation t.Run("GetKind_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState + var obj *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -288729,8 +289263,8 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotation t.Run("GetUnknown", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState{} - var expected *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + obj := &DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState{} + var expected *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown obj.Unknown = expected // Act & Assert @@ -288740,7 +289274,7 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotation t.Run("GetUnknown_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState{} obj.Unknown = nil // Act & Assert @@ -288749,7 +289283,7 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotation t.Run("GetUnknown_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState + var obj *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -288762,8 +289296,8 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotation t.Run("GetKnown", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState{} - var expected *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + obj := &DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState{} + var expected *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown obj.Known = expected // Act & Assert @@ -288773,7 +289307,7 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotation t.Run("GetKnown_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState{} obj.Known = nil // Act & Assert @@ -288782,7 +289316,7 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotation t.Run("GetKnown_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState + var obj *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationState // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -288794,9 +289328,9 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotation } -func TestSettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { +func TestSettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { t.Run("SetHasAnyWeakAnnotations", func(t *testing.T) { - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} var fernTestValueHasAnyWeakAnnotations bool obj.SetHasAnyWeakAnnotations(fernTestValueHasAnyWeakAnnotations) assert.Equal(t, fernTestValueHasAnyWeakAnnotations, obj.HasAnyWeakAnnotations) @@ -288805,11 +289339,11 @@ func TestSettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotation } -func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { +func TestGettersDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { t.Run("GetHasAnyWeakAnnotations", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} var expected bool obj.HasAnyWeakAnnotations = expected @@ -288819,7 +289353,7 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotation t.Run("GetHasAnyWeakAnnotations_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + var obj *DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -288831,11 +289365,11 @@ func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotation } -func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { +func TestSettersMarkExplicitDocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { t.Run("SetHasAnyWeakAnnotations_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + obj := &DocPagesMove200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} var fernTestValueHasAnyWeakAnnotations bool // Act @@ -288865,9 +289399,9 @@ func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaAffectedPagesItemWe } -func TestSettersDocRedactionsApply200ResponseMetaCacheDelta(t *testing.T) { +func TestSettersDocPagesMove200ResponseMetaCacheDelta(t *testing.T) { t.Run("SetPreviousDocVersion", func(t *testing.T) { - obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + obj := &DocPagesMove200ResponseMetaCacheDelta{} var fernTestValuePreviousDocVersion int obj.SetPreviousDocVersion(fernTestValuePreviousDocVersion) assert.Equal(t, fernTestValuePreviousDocVersion, obj.PreviousDocVersion) @@ -288875,7 +289409,7 @@ func TestSettersDocRedactionsApply200ResponseMetaCacheDelta(t *testing.T) { }) t.Run("SetDocVersion", func(t *testing.T) { - obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + obj := &DocPagesMove200ResponseMetaCacheDelta{} var fernTestValueDocVersion int obj.SetDocVersion(fernTestValueDocVersion) assert.Equal(t, fernTestValueDocVersion, obj.DocVersion) @@ -288883,8 +289417,8 @@ func TestSettersDocRedactionsApply200ResponseMetaCacheDelta(t *testing.T) { }) t.Run("SetPages", func(t *testing.T) { - obj := &DocRedactionsApply200ResponseMetaCacheDelta{} - var fernTestValuePages []*DocRedactionsApply200ResponseMetaCacheDeltaPagesItem + obj := &DocPagesMove200ResponseMetaCacheDelta{} + var fernTestValuePages []*DocPagesMove200ResponseMetaCacheDeltaPagesItem obj.SetPages(fernTestValuePages) assert.Equal(t, fernTestValuePages, obj.Pages) assert.NotNil(t, obj.explicitFields) @@ -288892,11 +289426,11 @@ func TestSettersDocRedactionsApply200ResponseMetaCacheDelta(t *testing.T) { } -func TestGettersDocRedactionsApply200ResponseMetaCacheDelta(t *testing.T) { +func TestGettersDocPagesMove200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetPreviousDocVersion", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + obj := &DocPagesMove200ResponseMetaCacheDelta{} var expected int obj.PreviousDocVersion = expected @@ -288906,7 +289440,7 @@ func TestGettersDocRedactionsApply200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetPreviousDocVersion_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaCacheDelta + var obj *DocPagesMove200ResponseMetaCacheDelta // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -288919,7 +289453,7 @@ func TestGettersDocRedactionsApply200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetDocVersion", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + obj := &DocPagesMove200ResponseMetaCacheDelta{} var expected int obj.DocVersion = expected @@ -288929,7 +289463,7 @@ func TestGettersDocRedactionsApply200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetDocVersion_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaCacheDelta + var obj *DocPagesMove200ResponseMetaCacheDelta // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -288942,8 +289476,8 @@ func TestGettersDocRedactionsApply200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetPages", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaCacheDelta{} - var expected []*DocRedactionsApply200ResponseMetaCacheDeltaPagesItem + obj := &DocPagesMove200ResponseMetaCacheDelta{} + var expected []*DocPagesMove200ResponseMetaCacheDeltaPagesItem obj.Pages = expected // Act & Assert @@ -288953,7 +289487,7 @@ func TestGettersDocRedactionsApply200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetPages_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + obj := &DocPagesMove200ResponseMetaCacheDelta{} obj.Pages = nil // Act & Assert @@ -288962,7 +289496,7 @@ func TestGettersDocRedactionsApply200ResponseMetaCacheDelta(t *testing.T) { t.Run("GetPages_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaCacheDelta + var obj *DocPagesMove200ResponseMetaCacheDelta // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -288974,11 +289508,11 @@ func TestGettersDocRedactionsApply200ResponseMetaCacheDelta(t *testing.T) { } -func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaCacheDelta(t *testing.T) { +func TestSettersMarkExplicitDocPagesMove200ResponseMetaCacheDelta(t *testing.T) { t.Run("SetPreviousDocVersion_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + obj := &DocPagesMove200ResponseMetaCacheDelta{} var fernTestValuePreviousDocVersion int // Act @@ -289009,7 +289543,7 @@ func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaCacheDelta(t *testi t.Run("SetDocVersion_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + obj := &DocPagesMove200ResponseMetaCacheDelta{} var fernTestValueDocVersion int // Act @@ -289040,8 +289574,8 @@ func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaCacheDelta(t *testi t.Run("SetPages_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaCacheDelta{} - var fernTestValuePages []*DocRedactionsApply200ResponseMetaCacheDeltaPagesItem + obj := &DocPagesMove200ResponseMetaCacheDelta{} + var fernTestValuePages []*DocPagesMove200ResponseMetaCacheDeltaPagesItem // Act obj.SetPages(fernTestValuePages) @@ -289070,9 +289604,9 @@ func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaCacheDelta(t *testi } -func TestSettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItem(t *testing.T) { +func TestSettersDocPagesMove200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("SetPageObjectNumber", func(t *testing.T) { - obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItem{} + obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItem{} var fernTestValuePageObjectNumber int obj.SetPageObjectNumber(fernTestValuePageObjectNumber) assert.Equal(t, fernTestValuePageObjectNumber, obj.PageObjectNumber) @@ -289080,8 +289614,8 @@ func TestSettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItem(t *testing. }) t.Run("SetCache", func(t *testing.T) { - obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItem{} - var fernTestValueCache *DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache + obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItem{} + var fernTestValueCache *DocPagesMove200ResponseMetaCacheDeltaPagesItemCache obj.SetCache(fernTestValueCache) assert.Equal(t, fernTestValueCache, obj.Cache) assert.NotNil(t, obj.explicitFields) @@ -289089,11 +289623,11 @@ func TestSettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItem(t *testing. } -func TestGettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItem(t *testing.T) { +func TestGettersDocPagesMove200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("GetPageObjectNumber", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItem{} + obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItem{} var expected int obj.PageObjectNumber = expected @@ -289103,7 +289637,7 @@ func TestGettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItem(t *testing. t.Run("GetPageObjectNumber_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaCacheDeltaPagesItem + var obj *DocPagesMove200ResponseMetaCacheDeltaPagesItem // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -289116,8 +289650,8 @@ func TestGettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItem(t *testing. t.Run("GetCache", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItem{} - var expected *DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache + obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItem{} + var expected *DocPagesMove200ResponseMetaCacheDeltaPagesItemCache obj.Cache = expected // Act & Assert @@ -289127,7 +289661,7 @@ func TestGettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItem(t *testing. t.Run("GetCache_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItem{} + obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItem{} obj.Cache = nil // Act & Assert @@ -289136,7 +289670,7 @@ func TestGettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItem(t *testing. t.Run("GetCache_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaCacheDeltaPagesItem + var obj *DocPagesMove200ResponseMetaCacheDeltaPagesItem // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -289148,11 +289682,11 @@ func TestGettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItem(t *testing. } -func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaCacheDeltaPagesItem(t *testing.T) { +func TestSettersMarkExplicitDocPagesMove200ResponseMetaCacheDeltaPagesItem(t *testing.T) { t.Run("SetPageObjectNumber_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItem{} + obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItem{} var fernTestValuePageObjectNumber int // Act @@ -289183,8 +289717,8 @@ func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaCacheDeltaPagesItem t.Run("SetCache_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItem{} - var fernTestValueCache *DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache + obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItem{} + var fernTestValueCache *DocPagesMove200ResponseMetaCacheDeltaPagesItemCache // Act obj.SetCache(fernTestValueCache) @@ -289213,9 +289747,9 @@ func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaCacheDeltaPagesItem } -func TestSettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { +func TestSettersDocPagesMove200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { t.Run("SetContentVersion", func(t *testing.T) { - obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItemCache{} var fernTestValueContentVersion int obj.SetContentVersion(fernTestValueContentVersion) assert.Equal(t, fernTestValueContentVersion, obj.ContentVersion) @@ -289223,7 +289757,7 @@ func TestSettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache(t *tes }) t.Run("SetAnnotationVersion", func(t *testing.T) { - obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItemCache{} var fernTestValueAnnotationVersion int obj.SetAnnotationVersion(fernTestValueAnnotationVersion) assert.Equal(t, fernTestValueAnnotationVersion, obj.AnnotationVersion) @@ -289232,11 +289766,11 @@ func TestSettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache(t *tes } -func TestGettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { +func TestGettersDocPagesMove200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { t.Run("GetContentVersion", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItemCache{} var expected int obj.ContentVersion = expected @@ -289246,7 +289780,7 @@ func TestGettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache(t *tes t.Run("GetContentVersion_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache + var obj *DocPagesMove200ResponseMetaCacheDeltaPagesItemCache // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -289259,7 +289793,7 @@ func TestGettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache(t *tes t.Run("GetAnnotationVersion", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItemCache{} var expected int obj.AnnotationVersion = expected @@ -289269,7 +289803,7 @@ func TestGettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache(t *tes t.Run("GetAnnotationVersion_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache + var obj *DocPagesMove200ResponseMetaCacheDeltaPagesItemCache // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -289281,11 +289815,11 @@ func TestGettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache(t *tes } -func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { +func TestSettersMarkExplicitDocPagesMove200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { t.Run("SetContentVersion_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItemCache{} var fernTestValueContentVersion int // Act @@ -289316,7 +289850,7 @@ func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaCacheDeltaPagesItem t.Run("SetAnnotationVersion_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache{} + obj := &DocPagesMove200ResponseMetaCacheDeltaPagesItemCache{} var fernTestValueAnnotationVersion int // Act @@ -289346,25 +289880,25 @@ func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaCacheDeltaPagesItem } -func TestSettersDocRedactionsApply400Response(t *testing.T) { +func TestSettersDocPagesMove400Response(t *testing.T) { t.Run("SetName", func(t *testing.T) { - obj := &DocRedactionsApply400Response{} - var fernTestValueName DocRedactionsApply400ResponseName + obj := &DocPagesMove400Response{} + var fernTestValueName DocPagesMove400ResponseName obj.SetName(fernTestValueName) assert.Equal(t, fernTestValueName, obj.Name) assert.NotNil(t, obj.explicitFields) }) t.Run("SetCode", func(t *testing.T) { - obj := &DocRedactionsApply400Response{} - var fernTestValueCode DocRedactionsApply400ResponseCode + obj := &DocPagesMove400Response{} + var fernTestValueCode DocPagesMove400ResponseCode obj.SetCode(fernTestValueCode) assert.Equal(t, fernTestValueCode, obj.Code) assert.NotNil(t, obj.explicitFields) }) t.Run("SetMessage", func(t *testing.T) { - obj := &DocRedactionsApply400Response{} + obj := &DocPagesMove400Response{} var fernTestValueMessage string obj.SetMessage(fernTestValueMessage) assert.Equal(t, fernTestValueMessage, obj.Message) @@ -289372,7 +289906,7 @@ func TestSettersDocRedactionsApply400Response(t *testing.T) { }) t.Run("SetDetails", func(t *testing.T) { - obj := &DocRedactionsApply400Response{} + obj := &DocPagesMove400Response{} var fernTestValueDetails map[string]any obj.SetDetails(fernTestValueDetails) assert.Equal(t, fernTestValueDetails, obj.Details) @@ -289381,12 +289915,12 @@ func TestSettersDocRedactionsApply400Response(t *testing.T) { } -func TestGettersDocRedactionsApply400Response(t *testing.T) { +func TestGettersDocPagesMove400Response(t *testing.T) { t.Run("GetName", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply400Response{} - var expected DocRedactionsApply400ResponseName + obj := &DocPagesMove400Response{} + var expected DocPagesMove400ResponseName obj.Name = expected // Act & Assert @@ -289395,7 +289929,7 @@ func TestGettersDocRedactionsApply400Response(t *testing.T) { t.Run("GetName_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply400Response + var obj *DocPagesMove400Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -289408,8 +289942,8 @@ func TestGettersDocRedactionsApply400Response(t *testing.T) { t.Run("GetCode", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply400Response{} - var expected DocRedactionsApply400ResponseCode + obj := &DocPagesMove400Response{} + var expected DocPagesMove400ResponseCode obj.Code = expected // Act & Assert @@ -289418,7 +289952,7 @@ func TestGettersDocRedactionsApply400Response(t *testing.T) { t.Run("GetCode_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply400Response + var obj *DocPagesMove400Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -289431,7 +289965,7 @@ func TestGettersDocRedactionsApply400Response(t *testing.T) { t.Run("GetMessage", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply400Response{} + obj := &DocPagesMove400Response{} var expected string obj.Message = expected @@ -289441,7 +289975,7 @@ func TestGettersDocRedactionsApply400Response(t *testing.T) { t.Run("GetMessage_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply400Response + var obj *DocPagesMove400Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -289454,7 +289988,7 @@ func TestGettersDocRedactionsApply400Response(t *testing.T) { t.Run("GetDetails", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply400Response{} + obj := &DocPagesMove400Response{} var expected map[string]any obj.Details = expected @@ -289465,7 +289999,7 @@ func TestGettersDocRedactionsApply400Response(t *testing.T) { t.Run("GetDetails_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply400Response{} + obj := &DocPagesMove400Response{} obj.Details = nil // Act & Assert @@ -289474,7 +290008,7 @@ func TestGettersDocRedactionsApply400Response(t *testing.T) { t.Run("GetDetails_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply400Response + var obj *DocPagesMove400Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -289486,12 +290020,12 @@ func TestGettersDocRedactionsApply400Response(t *testing.T) { } -func TestSettersMarkExplicitDocRedactionsApply400Response(t *testing.T) { +func TestSettersMarkExplicitDocPagesMove400Response(t *testing.T) { t.Run("SetName_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply400Response{} - var fernTestValueName DocRedactionsApply400ResponseName + obj := &DocPagesMove400Response{} + var fernTestValueName DocPagesMove400ResponseName // Act obj.SetName(fernTestValueName) @@ -289521,8 +290055,8 @@ func TestSettersMarkExplicitDocRedactionsApply400Response(t *testing.T) { t.Run("SetCode_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply400Response{} - var fernTestValueCode DocRedactionsApply400ResponseCode + obj := &DocPagesMove400Response{} + var fernTestValueCode DocPagesMove400ResponseCode // Act obj.SetCode(fernTestValueCode) @@ -289552,7 +290086,7 @@ func TestSettersMarkExplicitDocRedactionsApply400Response(t *testing.T) { t.Run("SetMessage_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply400Response{} + obj := &DocPagesMove400Response{} var fernTestValueMessage string // Act @@ -289583,7 +290117,7 @@ func TestSettersMarkExplicitDocRedactionsApply400Response(t *testing.T) { t.Run("SetDetails_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply400Response{} + obj := &DocPagesMove400Response{} var fernTestValueDetails map[string]any // Act @@ -289613,25 +290147,25 @@ func TestSettersMarkExplicitDocRedactionsApply400Response(t *testing.T) { } -func TestSettersDocRedactionsApply404Response(t *testing.T) { +func TestSettersDocPagesMove404Response(t *testing.T) { t.Run("SetName", func(t *testing.T) { - obj := &DocRedactionsApply404Response{} - var fernTestValueName DocRedactionsApply404ResponseName + obj := &DocPagesMove404Response{} + var fernTestValueName DocPagesMove404ResponseName obj.SetName(fernTestValueName) assert.Equal(t, fernTestValueName, obj.Name) assert.NotNil(t, obj.explicitFields) }) t.Run("SetCode", func(t *testing.T) { - obj := &DocRedactionsApply404Response{} - var fernTestValueCode DocRedactionsApply404ResponseCode + obj := &DocPagesMove404Response{} + var fernTestValueCode DocPagesMove404ResponseCode obj.SetCode(fernTestValueCode) assert.Equal(t, fernTestValueCode, obj.Code) assert.NotNil(t, obj.explicitFields) }) t.Run("SetMessage", func(t *testing.T) { - obj := &DocRedactionsApply404Response{} + obj := &DocPagesMove404Response{} var fernTestValueMessage string obj.SetMessage(fernTestValueMessage) assert.Equal(t, fernTestValueMessage, obj.Message) @@ -289639,7 +290173,7 @@ func TestSettersDocRedactionsApply404Response(t *testing.T) { }) t.Run("SetDetails", func(t *testing.T) { - obj := &DocRedactionsApply404Response{} + obj := &DocPagesMove404Response{} var fernTestValueDetails map[string]any obj.SetDetails(fernTestValueDetails) assert.Equal(t, fernTestValueDetails, obj.Details) @@ -289648,12 +290182,12 @@ func TestSettersDocRedactionsApply404Response(t *testing.T) { } -func TestGettersDocRedactionsApply404Response(t *testing.T) { +func TestGettersDocPagesMove404Response(t *testing.T) { t.Run("GetName", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply404Response{} - var expected DocRedactionsApply404ResponseName + obj := &DocPagesMove404Response{} + var expected DocPagesMove404ResponseName obj.Name = expected // Act & Assert @@ -289662,7 +290196,7 @@ func TestGettersDocRedactionsApply404Response(t *testing.T) { t.Run("GetName_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply404Response + var obj *DocPagesMove404Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -289675,8 +290209,8 @@ func TestGettersDocRedactionsApply404Response(t *testing.T) { t.Run("GetCode", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply404Response{} - var expected DocRedactionsApply404ResponseCode + obj := &DocPagesMove404Response{} + var expected DocPagesMove404ResponseCode obj.Code = expected // Act & Assert @@ -289685,7 +290219,7 @@ func TestGettersDocRedactionsApply404Response(t *testing.T) { t.Run("GetCode_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply404Response + var obj *DocPagesMove404Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -289698,7 +290232,7 @@ func TestGettersDocRedactionsApply404Response(t *testing.T) { t.Run("GetMessage", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply404Response{} + obj := &DocPagesMove404Response{} var expected string obj.Message = expected @@ -289708,7 +290242,7 @@ func TestGettersDocRedactionsApply404Response(t *testing.T) { t.Run("GetMessage_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply404Response + var obj *DocPagesMove404Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -289721,7 +290255,7 @@ func TestGettersDocRedactionsApply404Response(t *testing.T) { t.Run("GetDetails", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply404Response{} + obj := &DocPagesMove404Response{} var expected map[string]any obj.Details = expected @@ -289732,7 +290266,7 @@ func TestGettersDocRedactionsApply404Response(t *testing.T) { t.Run("GetDetails_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply404Response{} + obj := &DocPagesMove404Response{} obj.Details = nil // Act & Assert @@ -289741,7 +290275,7 @@ func TestGettersDocRedactionsApply404Response(t *testing.T) { t.Run("GetDetails_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRedactionsApply404Response + var obj *DocPagesMove404Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { @@ -289753,12 +290287,12 @@ func TestGettersDocRedactionsApply404Response(t *testing.T) { } -func TestSettersMarkExplicitDocRedactionsApply404Response(t *testing.T) { +func TestSettersMarkExplicitDocPagesMove404Response(t *testing.T) { t.Run("SetName_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply404Response{} - var fernTestValueName DocRedactionsApply404ResponseName + obj := &DocPagesMove404Response{} + var fernTestValueName DocPagesMove404ResponseName // Act obj.SetName(fernTestValueName) @@ -289788,8 +290322,8 @@ func TestSettersMarkExplicitDocRedactionsApply404Response(t *testing.T) { t.Run("SetCode_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply404Response{} - var fernTestValueCode DocRedactionsApply404ResponseCode + obj := &DocPagesMove404Response{} + var fernTestValueCode DocPagesMove404ResponseCode // Act obj.SetCode(fernTestValueCode) @@ -289819,7 +290353,7 @@ func TestSettersMarkExplicitDocRedactionsApply404Response(t *testing.T) { t.Run("SetMessage_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply404Response{} + obj := &DocPagesMove404Response{} var fernTestValueMessage string // Act @@ -289850,7 +290384,7 @@ func TestSettersMarkExplicitDocRedactionsApply404Response(t *testing.T) { t.Run("SetDetails_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRedactionsApply404Response{} + obj := &DocPagesMove404Response{} var fernTestValueDetails map[string]any // Act @@ -289880,155 +290414,3799 @@ func TestSettersMarkExplicitDocRedactionsApply404Response(t *testing.T) { } -func TestSettersDocRenderResponse(t *testing.T) { - t.Run("SetName", func(t *testing.T) { - obj := &DocRenderResponse{} - var fernTestValueName DocRenderResponseName - obj.SetName(fernTestValueName) - assert.Equal(t, fernTestValueName, obj.Name) - assert.NotNil(t, obj.explicitFields) - }) - - t.Run("SetCode", func(t *testing.T) { - obj := &DocRenderResponse{} - var fernTestValueCode DocRenderResponseCode - obj.SetCode(fernTestValueCode) - assert.Equal(t, fernTestValueCode, obj.Code) - assert.NotNil(t, obj.explicitFields) - }) - - t.Run("SetMessage", func(t *testing.T) { - obj := &DocRenderResponse{} - var fernTestValueMessage string - obj.SetMessage(fernTestValueMessage) - assert.Equal(t, fernTestValueMessage, obj.Message) - assert.NotNil(t, obj.explicitFields) - }) - - t.Run("SetDetails", func(t *testing.T) { - obj := &DocRenderResponse{} - var fernTestValueDetails map[string]any - obj.SetDetails(fernTestValueDetails) - assert.Equal(t, fernTestValueDetails, obj.Details) +func TestSettersDocPagesRotate200Response(t *testing.T) { + t.Run("SetMeta", func(t *testing.T) { + obj := &DocPagesRotate200Response{} + var fernTestValueMeta *DocPagesRotate200ResponseMeta + obj.SetMeta(fernTestValueMeta) + assert.Equal(t, fernTestValueMeta, obj.Meta) assert.NotNil(t, obj.explicitFields) }) } -func TestGettersDocRenderResponse(t *testing.T) { - t.Run("GetName", func(t *testing.T) { - t.Parallel() - // Arrange - obj := &DocRenderResponse{} - var expected DocRenderResponseName - obj.Name = expected - - // Act & Assert - assert.Equal(t, expected, obj.GetName(), "getter should return the property value") - }) - - t.Run("GetName_NilReceiver", func(t *testing.T) { - t.Parallel() - var obj *DocRenderResponse - // Should not panic - getters should handle nil receiver gracefully - defer func() { - if r := recover(); r != nil { - t.Errorf("Getter panicked on nil receiver: %v", r) - } - }() - _ = obj.GetName() // Should return zero value - }) - - t.Run("GetCode", func(t *testing.T) { - t.Parallel() - // Arrange - obj := &DocRenderResponse{} - var expected DocRenderResponseCode - obj.Code = expected - - // Act & Assert - assert.Equal(t, expected, obj.GetCode(), "getter should return the property value") - }) - - t.Run("GetCode_NilReceiver", func(t *testing.T) { - t.Parallel() - var obj *DocRenderResponse - // Should not panic - getters should handle nil receiver gracefully - defer func() { - if r := recover(); r != nil { - t.Errorf("Getter panicked on nil receiver: %v", r) - } - }() - _ = obj.GetCode() // Should return zero value - }) - - t.Run("GetMessage", func(t *testing.T) { - t.Parallel() - // Arrange - obj := &DocRenderResponse{} - var expected string - obj.Message = expected - - // Act & Assert - assert.Equal(t, expected, obj.GetMessage(), "getter should return the property value") - }) - - t.Run("GetMessage_NilReceiver", func(t *testing.T) { - t.Parallel() - var obj *DocRenderResponse - // Should not panic - getters should handle nil receiver gracefully - defer func() { - if r := recover(); r != nil { - t.Errorf("Getter panicked on nil receiver: %v", r) - } - }() - _ = obj.GetMessage() // Should return zero value - }) - - t.Run("GetDetails", func(t *testing.T) { +func TestGettersDocPagesRotate200Response(t *testing.T) { + t.Run("GetMeta", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRenderResponse{} - var expected map[string]any - obj.Details = expected + obj := &DocPagesRotate200Response{} + var expected *DocPagesRotate200ResponseMeta + obj.Meta = expected // Act & Assert - assert.Equal(t, expected, obj.GetDetails(), "getter should return the property value") + assert.Equal(t, expected, obj.GetMeta(), "getter should return the property value") }) - t.Run("GetDetails_NilValue", func(t *testing.T) { + t.Run("GetMeta_NilValue", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRenderResponse{} - obj.Details = nil + obj := &DocPagesRotate200Response{} + obj.Meta = nil // Act & Assert - assert.Nil(t, obj.GetDetails(), "getter should return nil when property is nil") + assert.Nil(t, obj.GetMeta(), "getter should return nil when property is nil") }) - t.Run("GetDetails_NilReceiver", func(t *testing.T) { + t.Run("GetMeta_NilReceiver", func(t *testing.T) { t.Parallel() - var obj *DocRenderResponse + var obj *DocPagesRotate200Response // Should not panic - getters should handle nil receiver gracefully defer func() { if r := recover(); r != nil { t.Errorf("Getter panicked on nil receiver: %v", r) } }() - _ = obj.GetDetails() // Should return zero value + _ = obj.GetMeta() // Should return zero value }) } -func TestSettersMarkExplicitDocRenderResponse(t *testing.T) { - t.Run("SetName_MarksExplicit", func(t *testing.T) { +func TestSettersMarkExplicitDocPagesRotate200Response(t *testing.T) { + t.Run("SetMeta_MarksExplicit", func(t *testing.T) { t.Parallel() // Arrange - obj := &DocRenderResponse{} - var fernTestValueName DocRenderResponseName + obj := &DocPagesRotate200Response{} + var fernTestValueMeta *DocPagesRotate200ResponseMeta // Act - obj.SetName(fernTestValueName) + obj.SetMeta(fernTestValueMeta) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocPagesRotate200ResponseMeta(t *testing.T) { + t.Run("SetAffectedPages", func(t *testing.T) { + obj := &DocPagesRotate200ResponseMeta{} + var fernTestValueAffectedPages []*DocPagesRotate200ResponseMetaAffectedPagesItem + obj.SetAffectedPages(fernTestValueAffectedPages) + assert.Equal(t, fernTestValueAffectedPages, obj.AffectedPages) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetCacheDelta", func(t *testing.T) { + obj := &DocPagesRotate200ResponseMeta{} + var fernTestValueCacheDelta *DocPagesRotate200ResponseMetaCacheDelta + obj.SetCacheDelta(fernTestValueCacheDelta) + assert.Equal(t, fernTestValueCacheDelta, obj.CacheDelta) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocPagesRotate200ResponseMeta(t *testing.T) { + t.Run("GetAffectedPages", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMeta{} + var expected []*DocPagesRotate200ResponseMetaAffectedPagesItem + obj.AffectedPages = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetAffectedPages(), "getter should return the property value") + }) + + t.Run("GetAffectedPages_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMeta{} + obj.AffectedPages = nil + + // Act & Assert + assert.Nil(t, obj.GetAffectedPages(), "getter should return nil when property is nil") + }) + + t.Run("GetAffectedPages_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMeta + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetAffectedPages() // Should return zero value + }) + + t.Run("GetCacheDelta", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMeta{} + var expected *DocPagesRotate200ResponseMetaCacheDelta + obj.CacheDelta = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetCacheDelta(), "getter should return the property value") + }) + + t.Run("GetCacheDelta_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMeta{} + obj.CacheDelta = nil + + // Act & Assert + assert.Nil(t, obj.GetCacheDelta(), "getter should return nil when property is nil") + }) + + t.Run("GetCacheDelta_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMeta + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetCacheDelta() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocPagesRotate200ResponseMeta(t *testing.T) { + t.Run("SetAffectedPages_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMeta{} + var fernTestValueAffectedPages []*DocPagesRotate200ResponseMetaAffectedPagesItem + + // Act + obj.SetAffectedPages(fernTestValueAffectedPages) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetCacheDelta_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMeta{} + var fernTestValueCacheDelta *DocPagesRotate200ResponseMetaCacheDelta + + // Act + obj.SetCacheDelta(fernTestValueCacheDelta) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocPagesRotate200ResponseMetaAffectedPagesItem(t *testing.T) { + t.Run("SetPageObjectNumber", func(t *testing.T) { + obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} + var fernTestValuePageObjectNumber int + obj.SetPageObjectNumber(fernTestValuePageObjectNumber) + assert.Equal(t, fernTestValuePageObjectNumber, obj.PageObjectNumber) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetRevision", func(t *testing.T) { + obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} + var fernTestValueRevision *DocPagesRotate200ResponseMetaAffectedPagesItemRevision + obj.SetRevision(fernTestValueRevision) + assert.Equal(t, fernTestValueRevision, obj.Revision) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetWeakAnnotationState", func(t *testing.T) { + obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} + var fernTestValueWeakAnnotationState *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState + obj.SetWeakAnnotationState(fernTestValueWeakAnnotationState) + assert.Equal(t, fernTestValueWeakAnnotationState, obj.WeakAnnotationState) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItem(t *testing.T) { + t.Run("GetPageObjectNumber", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} + var expected int + obj.PageObjectNumber = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetPageObjectNumber(), "getter should return the property value") + }) + + t.Run("GetPageObjectNumber_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaAffectedPagesItem + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetPageObjectNumber() // Should return zero value + }) + + t.Run("GetRevision", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} + var expected *DocPagesRotate200ResponseMetaAffectedPagesItemRevision + obj.Revision = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetRevision(), "getter should return the property value") + }) + + t.Run("GetRevision_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} + obj.Revision = nil + + // Act & Assert + assert.Nil(t, obj.GetRevision(), "getter should return nil when property is nil") + }) + + t.Run("GetRevision_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaAffectedPagesItem + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetRevision() // Should return zero value + }) + + t.Run("GetWeakAnnotationState", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} + var expected *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState + obj.WeakAnnotationState = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetWeakAnnotationState(), "getter should return the property value") + }) + + t.Run("GetWeakAnnotationState_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} + obj.WeakAnnotationState = nil + + // Act & Assert + assert.Nil(t, obj.GetWeakAnnotationState(), "getter should return nil when property is nil") + }) + + t.Run("GetWeakAnnotationState_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaAffectedPagesItem + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetWeakAnnotationState() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocPagesRotate200ResponseMetaAffectedPagesItem(t *testing.T) { + t.Run("SetPageObjectNumber_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} + var fernTestValuePageObjectNumber int + + // Act + obj.SetPageObjectNumber(fernTestValuePageObjectNumber) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetRevision_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} + var fernTestValueRevision *DocPagesRotate200ResponseMetaAffectedPagesItemRevision + + // Act + obj.SetRevision(fernTestValueRevision) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetWeakAnnotationState_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItem{} + var fernTestValueWeakAnnotationState *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState + + // Act + obj.SetWeakAnnotationState(fernTestValueWeakAnnotationState) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocPagesRotate200ResponseMetaAffectedPagesItemRevision(t *testing.T) { + t.Run("SetDocSessionID", func(t *testing.T) { + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + var fernTestValueDocSessionID string + obj.SetDocSessionID(fernTestValueDocSessionID) + assert.Equal(t, fernTestValueDocSessionID, obj.DocSessionID) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetPageObjectNumber", func(t *testing.T) { + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + var fernTestValuePageObjectNumber int + obj.SetPageObjectNumber(fernTestValuePageObjectNumber) + assert.Equal(t, fernTestValuePageObjectNumber, obj.PageObjectNumber) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetGeneration", func(t *testing.T) { + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + var fernTestValueGeneration int + obj.SetGeneration(fernTestValueGeneration) + assert.Equal(t, fernTestValueGeneration, obj.Generation) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemRevision(t *testing.T) { + t.Run("GetDocSessionID", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + var expected string + obj.DocSessionID = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetDocSessionID(), "getter should return the property value") + }) + + t.Run("GetDocSessionID_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaAffectedPagesItemRevision + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetDocSessionID() // Should return zero value + }) + + t.Run("GetPageObjectNumber", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + var expected int + obj.PageObjectNumber = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetPageObjectNumber(), "getter should return the property value") + }) + + t.Run("GetPageObjectNumber_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaAffectedPagesItemRevision + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetPageObjectNumber() // Should return zero value + }) + + t.Run("GetGeneration", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + var expected int + obj.Generation = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetGeneration(), "getter should return the property value") + }) + + t.Run("GetGeneration_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaAffectedPagesItemRevision + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetGeneration() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocPagesRotate200ResponseMetaAffectedPagesItemRevision(t *testing.T) { + t.Run("SetDocSessionID_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + var fernTestValueDocSessionID string + + // Act + obj.SetDocSessionID(fernTestValueDocSessionID) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetPageObjectNumber_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + var fernTestValuePageObjectNumber int + + // Act + obj.SetPageObjectNumber(fernTestValuePageObjectNumber) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetGeneration_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemRevision{} + var fernTestValueGeneration int + + // Act + obj.SetGeneration(fernTestValueGeneration) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState(t *testing.T) { + t.Run("GetKind", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState{} + var expected string + obj.Kind = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetKind(), "getter should return the property value") + }) + + t.Run("GetKind_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetKind() // Should return zero value + }) + + t.Run("GetUnknown", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState{} + var expected *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + obj.Unknown = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetUnknown(), "getter should return the property value") + }) + + t.Run("GetUnknown_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState{} + obj.Unknown = nil + + // Act & Assert + assert.Nil(t, obj.GetUnknown(), "getter should return nil when property is nil") + }) + + t.Run("GetUnknown_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetUnknown() // Should return zero value + }) + + t.Run("GetKnown", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState{} + var expected *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + obj.Known = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetKnown(), "getter should return the property value") + }) + + t.Run("GetKnown_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState{} + obj.Known = nil + + // Act & Assert + assert.Nil(t, obj.GetKnown(), "getter should return nil when property is nil") + }) + + t.Run("GetKnown_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationState + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetKnown() // Should return zero value + }) + +} + +func TestSettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { + t.Run("SetHasAnyWeakAnnotations", func(t *testing.T) { + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + var fernTestValueHasAnyWeakAnnotations bool + obj.SetHasAnyWeakAnnotations(fernTestValueHasAnyWeakAnnotations) + assert.Equal(t, fernTestValueHasAnyWeakAnnotations, obj.HasAnyWeakAnnotations) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { + t.Run("GetHasAnyWeakAnnotations", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + var expected bool + obj.HasAnyWeakAnnotations = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetHasAnyWeakAnnotations(), "getter should return the property value") + }) + + t.Run("GetHasAnyWeakAnnotations_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetHasAnyWeakAnnotations() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { + t.Run("SetHasAnyWeakAnnotations_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + var fernTestValueHasAnyWeakAnnotations bool + + // Act + obj.SetHasAnyWeakAnnotations(fernTestValueHasAnyWeakAnnotations) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocPagesRotate200ResponseMetaCacheDelta(t *testing.T) { + t.Run("SetPreviousDocVersion", func(t *testing.T) { + obj := &DocPagesRotate200ResponseMetaCacheDelta{} + var fernTestValuePreviousDocVersion int + obj.SetPreviousDocVersion(fernTestValuePreviousDocVersion) + assert.Equal(t, fernTestValuePreviousDocVersion, obj.PreviousDocVersion) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetDocVersion", func(t *testing.T) { + obj := &DocPagesRotate200ResponseMetaCacheDelta{} + var fernTestValueDocVersion int + obj.SetDocVersion(fernTestValueDocVersion) + assert.Equal(t, fernTestValueDocVersion, obj.DocVersion) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetPages", func(t *testing.T) { + obj := &DocPagesRotate200ResponseMetaCacheDelta{} + var fernTestValuePages []*DocPagesRotate200ResponseMetaCacheDeltaPagesItem + obj.SetPages(fernTestValuePages) + assert.Equal(t, fernTestValuePages, obj.Pages) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocPagesRotate200ResponseMetaCacheDelta(t *testing.T) { + t.Run("GetPreviousDocVersion", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaCacheDelta{} + var expected int + obj.PreviousDocVersion = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetPreviousDocVersion(), "getter should return the property value") + }) + + t.Run("GetPreviousDocVersion_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaCacheDelta + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetPreviousDocVersion() // Should return zero value + }) + + t.Run("GetDocVersion", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaCacheDelta{} + var expected int + obj.DocVersion = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetDocVersion(), "getter should return the property value") + }) + + t.Run("GetDocVersion_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaCacheDelta + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetDocVersion() // Should return zero value + }) + + t.Run("GetPages", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaCacheDelta{} + var expected []*DocPagesRotate200ResponseMetaCacheDeltaPagesItem + obj.Pages = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetPages(), "getter should return the property value") + }) + + t.Run("GetPages_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaCacheDelta{} + obj.Pages = nil + + // Act & Assert + assert.Nil(t, obj.GetPages(), "getter should return nil when property is nil") + }) + + t.Run("GetPages_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaCacheDelta + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetPages() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocPagesRotate200ResponseMetaCacheDelta(t *testing.T) { + t.Run("SetPreviousDocVersion_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaCacheDelta{} + var fernTestValuePreviousDocVersion int + + // Act + obj.SetPreviousDocVersion(fernTestValuePreviousDocVersion) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetDocVersion_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaCacheDelta{} + var fernTestValueDocVersion int + + // Act + obj.SetDocVersion(fernTestValueDocVersion) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetPages_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaCacheDelta{} + var fernTestValuePages []*DocPagesRotate200ResponseMetaCacheDeltaPagesItem + + // Act + obj.SetPages(fernTestValuePages) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocPagesRotate200ResponseMetaCacheDeltaPagesItem(t *testing.T) { + t.Run("SetPageObjectNumber", func(t *testing.T) { + obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItem{} + var fernTestValuePageObjectNumber int + obj.SetPageObjectNumber(fernTestValuePageObjectNumber) + assert.Equal(t, fernTestValuePageObjectNumber, obj.PageObjectNumber) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetCache", func(t *testing.T) { + obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItem{} + var fernTestValueCache *DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache + obj.SetCache(fernTestValueCache) + assert.Equal(t, fernTestValueCache, obj.Cache) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocPagesRotate200ResponseMetaCacheDeltaPagesItem(t *testing.T) { + t.Run("GetPageObjectNumber", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItem{} + var expected int + obj.PageObjectNumber = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetPageObjectNumber(), "getter should return the property value") + }) + + t.Run("GetPageObjectNumber_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaCacheDeltaPagesItem + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetPageObjectNumber() // Should return zero value + }) + + t.Run("GetCache", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItem{} + var expected *DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache + obj.Cache = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetCache(), "getter should return the property value") + }) + + t.Run("GetCache_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItem{} + obj.Cache = nil + + // Act & Assert + assert.Nil(t, obj.GetCache(), "getter should return nil when property is nil") + }) + + t.Run("GetCache_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaCacheDeltaPagesItem + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetCache() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocPagesRotate200ResponseMetaCacheDeltaPagesItem(t *testing.T) { + t.Run("SetPageObjectNumber_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItem{} + var fernTestValuePageObjectNumber int + + // Act + obj.SetPageObjectNumber(fernTestValuePageObjectNumber) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetCache_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItem{} + var fernTestValueCache *DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache + + // Act + obj.SetCache(fernTestValueCache) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocPagesRotate200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { + t.Run("SetContentVersion", func(t *testing.T) { + obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache{} + var fernTestValueContentVersion int + obj.SetContentVersion(fernTestValueContentVersion) + assert.Equal(t, fernTestValueContentVersion, obj.ContentVersion) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetAnnotationVersion", func(t *testing.T) { + obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache{} + var fernTestValueAnnotationVersion int + obj.SetAnnotationVersion(fernTestValueAnnotationVersion) + assert.Equal(t, fernTestValueAnnotationVersion, obj.AnnotationVersion) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocPagesRotate200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { + t.Run("GetContentVersion", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache{} + var expected int + obj.ContentVersion = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetContentVersion(), "getter should return the property value") + }) + + t.Run("GetContentVersion_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetContentVersion() // Should return zero value + }) + + t.Run("GetAnnotationVersion", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache{} + var expected int + obj.AnnotationVersion = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetAnnotationVersion(), "getter should return the property value") + }) + + t.Run("GetAnnotationVersion_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetAnnotationVersion() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocPagesRotate200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { + t.Run("SetContentVersion_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache{} + var fernTestValueContentVersion int + + // Act + obj.SetContentVersion(fernTestValueContentVersion) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetAnnotationVersion_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate200ResponseMetaCacheDeltaPagesItemCache{} + var fernTestValueAnnotationVersion int + + // Act + obj.SetAnnotationVersion(fernTestValueAnnotationVersion) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocPagesRotate400Response(t *testing.T) { + t.Run("SetName", func(t *testing.T) { + obj := &DocPagesRotate400Response{} + var fernTestValueName DocPagesRotate400ResponseName + obj.SetName(fernTestValueName) + assert.Equal(t, fernTestValueName, obj.Name) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetCode", func(t *testing.T) { + obj := &DocPagesRotate400Response{} + var fernTestValueCode DocPagesRotate400ResponseCode + obj.SetCode(fernTestValueCode) + assert.Equal(t, fernTestValueCode, obj.Code) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetMessage", func(t *testing.T) { + obj := &DocPagesRotate400Response{} + var fernTestValueMessage string + obj.SetMessage(fernTestValueMessage) + assert.Equal(t, fernTestValueMessage, obj.Message) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetDetails", func(t *testing.T) { + obj := &DocPagesRotate400Response{} + var fernTestValueDetails map[string]any + obj.SetDetails(fernTestValueDetails) + assert.Equal(t, fernTestValueDetails, obj.Details) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocPagesRotate400Response(t *testing.T) { + t.Run("GetName", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate400Response{} + var expected DocPagesRotate400ResponseName + obj.Name = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetName(), "getter should return the property value") + }) + + t.Run("GetName_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate400Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetName() // Should return zero value + }) + + t.Run("GetCode", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate400Response{} + var expected DocPagesRotate400ResponseCode + obj.Code = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetCode(), "getter should return the property value") + }) + + t.Run("GetCode_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate400Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetCode() // Should return zero value + }) + + t.Run("GetMessage", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate400Response{} + var expected string + obj.Message = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetMessage(), "getter should return the property value") + }) + + t.Run("GetMessage_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate400Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetMessage() // Should return zero value + }) + + t.Run("GetDetails", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate400Response{} + var expected map[string]any + obj.Details = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetDetails(), "getter should return the property value") + }) + + t.Run("GetDetails_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate400Response{} + obj.Details = nil + + // Act & Assert + assert.Nil(t, obj.GetDetails(), "getter should return nil when property is nil") + }) + + t.Run("GetDetails_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate400Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetDetails() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocPagesRotate400Response(t *testing.T) { + t.Run("SetName_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate400Response{} + var fernTestValueName DocPagesRotate400ResponseName + + // Act + obj.SetName(fernTestValueName) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetCode_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate400Response{} + var fernTestValueCode DocPagesRotate400ResponseCode + + // Act + obj.SetCode(fernTestValueCode) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetMessage_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate400Response{} + var fernTestValueMessage string + + // Act + obj.SetMessage(fernTestValueMessage) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetDetails_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate400Response{} + var fernTestValueDetails map[string]any + + // Act + obj.SetDetails(fernTestValueDetails) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocPagesRotate404Response(t *testing.T) { + t.Run("SetName", func(t *testing.T) { + obj := &DocPagesRotate404Response{} + var fernTestValueName DocPagesRotate404ResponseName + obj.SetName(fernTestValueName) + assert.Equal(t, fernTestValueName, obj.Name) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetCode", func(t *testing.T) { + obj := &DocPagesRotate404Response{} + var fernTestValueCode DocPagesRotate404ResponseCode + obj.SetCode(fernTestValueCode) + assert.Equal(t, fernTestValueCode, obj.Code) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetMessage", func(t *testing.T) { + obj := &DocPagesRotate404Response{} + var fernTestValueMessage string + obj.SetMessage(fernTestValueMessage) + assert.Equal(t, fernTestValueMessage, obj.Message) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetDetails", func(t *testing.T) { + obj := &DocPagesRotate404Response{} + var fernTestValueDetails map[string]any + obj.SetDetails(fernTestValueDetails) + assert.Equal(t, fernTestValueDetails, obj.Details) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocPagesRotate404Response(t *testing.T) { + t.Run("GetName", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate404Response{} + var expected DocPagesRotate404ResponseName + obj.Name = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetName(), "getter should return the property value") + }) + + t.Run("GetName_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate404Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetName() // Should return zero value + }) + + t.Run("GetCode", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate404Response{} + var expected DocPagesRotate404ResponseCode + obj.Code = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetCode(), "getter should return the property value") + }) + + t.Run("GetCode_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate404Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetCode() // Should return zero value + }) + + t.Run("GetMessage", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate404Response{} + var expected string + obj.Message = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetMessage(), "getter should return the property value") + }) + + t.Run("GetMessage_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate404Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetMessage() // Should return zero value + }) + + t.Run("GetDetails", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate404Response{} + var expected map[string]any + obj.Details = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetDetails(), "getter should return the property value") + }) + + t.Run("GetDetails_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate404Response{} + obj.Details = nil + + // Act & Assert + assert.Nil(t, obj.GetDetails(), "getter should return nil when property is nil") + }) + + t.Run("GetDetails_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesRotate404Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetDetails() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocPagesRotate404Response(t *testing.T) { + t.Run("SetName_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate404Response{} + var fernTestValueName DocPagesRotate404ResponseName + + // Act + obj.SetName(fernTestValueName) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetCode_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate404Response{} + var fernTestValueCode DocPagesRotate404ResponseCode + + // Act + obj.SetCode(fernTestValueCode) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetMessage_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate404Response{} + var fernTestValueMessage string + + // Act + obj.SetMessage(fernTestValueMessage) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetDetails_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesRotate404Response{} + var fernTestValueDetails map[string]any + + // Act + obj.SetDetails(fernTestValueDetails) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocRedactionsApply200Response(t *testing.T) { + t.Run("SetMeta", func(t *testing.T) { + obj := &DocRedactionsApply200Response{} + var fernTestValueMeta *DocRedactionsApply200ResponseMeta + obj.SetMeta(fernTestValueMeta) + assert.Equal(t, fernTestValueMeta, obj.Meta) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocRedactionsApply200Response(t *testing.T) { + t.Run("GetMeta", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200Response{} + var expected *DocRedactionsApply200ResponseMeta + obj.Meta = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetMeta(), "getter should return the property value") + }) + + t.Run("GetMeta_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200Response{} + obj.Meta = nil + + // Act & Assert + assert.Nil(t, obj.GetMeta(), "getter should return nil when property is nil") + }) + + t.Run("GetMeta_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetMeta() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocRedactionsApply200Response(t *testing.T) { + t.Run("SetMeta_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200Response{} + var fernTestValueMeta *DocRedactionsApply200ResponseMeta + + // Act + obj.SetMeta(fernTestValueMeta) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocRedactionsApply200ResponseMeta(t *testing.T) { + t.Run("SetAffectedPages", func(t *testing.T) { + obj := &DocRedactionsApply200ResponseMeta{} + var fernTestValueAffectedPages []*DocRedactionsApply200ResponseMetaAffectedPagesItem + obj.SetAffectedPages(fernTestValueAffectedPages) + assert.Equal(t, fernTestValueAffectedPages, obj.AffectedPages) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetCacheDelta", func(t *testing.T) { + obj := &DocRedactionsApply200ResponseMeta{} + var fernTestValueCacheDelta *DocRedactionsApply200ResponseMetaCacheDelta + obj.SetCacheDelta(fernTestValueCacheDelta) + assert.Equal(t, fernTestValueCacheDelta, obj.CacheDelta) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocRedactionsApply200ResponseMeta(t *testing.T) { + t.Run("GetAffectedPages", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMeta{} + var expected []*DocRedactionsApply200ResponseMetaAffectedPagesItem + obj.AffectedPages = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetAffectedPages(), "getter should return the property value") + }) + + t.Run("GetAffectedPages_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMeta{} + obj.AffectedPages = nil + + // Act & Assert + assert.Nil(t, obj.GetAffectedPages(), "getter should return nil when property is nil") + }) + + t.Run("GetAffectedPages_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMeta + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetAffectedPages() // Should return zero value + }) + + t.Run("GetCacheDelta", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMeta{} + var expected *DocRedactionsApply200ResponseMetaCacheDelta + obj.CacheDelta = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetCacheDelta(), "getter should return the property value") + }) + + t.Run("GetCacheDelta_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMeta{} + obj.CacheDelta = nil + + // Act & Assert + assert.Nil(t, obj.GetCacheDelta(), "getter should return nil when property is nil") + }) + + t.Run("GetCacheDelta_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMeta + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetCacheDelta() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocRedactionsApply200ResponseMeta(t *testing.T) { + t.Run("SetAffectedPages_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMeta{} + var fernTestValueAffectedPages []*DocRedactionsApply200ResponseMetaAffectedPagesItem + + // Act + obj.SetAffectedPages(fernTestValueAffectedPages) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetCacheDelta_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMeta{} + var fernTestValueCacheDelta *DocRedactionsApply200ResponseMetaCacheDelta + + // Act + obj.SetCacheDelta(fernTestValueCacheDelta) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocRedactionsApply200ResponseMetaAffectedPagesItem(t *testing.T) { + t.Run("SetPageObjectNumber", func(t *testing.T) { + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} + var fernTestValuePageObjectNumber int + obj.SetPageObjectNumber(fernTestValuePageObjectNumber) + assert.Equal(t, fernTestValuePageObjectNumber, obj.PageObjectNumber) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetRevision", func(t *testing.T) { + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} + var fernTestValueRevision *DocRedactionsApply200ResponseMetaAffectedPagesItemRevision + obj.SetRevision(fernTestValueRevision) + assert.Equal(t, fernTestValueRevision, obj.Revision) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetWeakAnnotationState", func(t *testing.T) { + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} + var fernTestValueWeakAnnotationState *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState + obj.SetWeakAnnotationState(fernTestValueWeakAnnotationState) + assert.Equal(t, fernTestValueWeakAnnotationState, obj.WeakAnnotationState) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItem(t *testing.T) { + t.Run("GetPageObjectNumber", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} + var expected int + obj.PageObjectNumber = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetPageObjectNumber(), "getter should return the property value") + }) + + t.Run("GetPageObjectNumber_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaAffectedPagesItem + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetPageObjectNumber() // Should return zero value + }) + + t.Run("GetRevision", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} + var expected *DocRedactionsApply200ResponseMetaAffectedPagesItemRevision + obj.Revision = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetRevision(), "getter should return the property value") + }) + + t.Run("GetRevision_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} + obj.Revision = nil + + // Act & Assert + assert.Nil(t, obj.GetRevision(), "getter should return nil when property is nil") + }) + + t.Run("GetRevision_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaAffectedPagesItem + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetRevision() // Should return zero value + }) + + t.Run("GetWeakAnnotationState", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} + var expected *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState + obj.WeakAnnotationState = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetWeakAnnotationState(), "getter should return the property value") + }) + + t.Run("GetWeakAnnotationState_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} + obj.WeakAnnotationState = nil + + // Act & Assert + assert.Nil(t, obj.GetWeakAnnotationState(), "getter should return nil when property is nil") + }) + + t.Run("GetWeakAnnotationState_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaAffectedPagesItem + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetWeakAnnotationState() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaAffectedPagesItem(t *testing.T) { + t.Run("SetPageObjectNumber_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} + var fernTestValuePageObjectNumber int + + // Act + obj.SetPageObjectNumber(fernTestValuePageObjectNumber) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetRevision_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} + var fernTestValueRevision *DocRedactionsApply200ResponseMetaAffectedPagesItemRevision + + // Act + obj.SetRevision(fernTestValueRevision) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetWeakAnnotationState_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItem{} + var fernTestValueWeakAnnotationState *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState + + // Act + obj.SetWeakAnnotationState(fernTestValueWeakAnnotationState) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocRedactionsApply200ResponseMetaAffectedPagesItemRevision(t *testing.T) { + t.Run("SetDocSessionID", func(t *testing.T) { + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + var fernTestValueDocSessionID string + obj.SetDocSessionID(fernTestValueDocSessionID) + assert.Equal(t, fernTestValueDocSessionID, obj.DocSessionID) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetPageObjectNumber", func(t *testing.T) { + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + var fernTestValuePageObjectNumber int + obj.SetPageObjectNumber(fernTestValuePageObjectNumber) + assert.Equal(t, fernTestValuePageObjectNumber, obj.PageObjectNumber) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetGeneration", func(t *testing.T) { + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + var fernTestValueGeneration int + obj.SetGeneration(fernTestValueGeneration) + assert.Equal(t, fernTestValueGeneration, obj.Generation) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemRevision(t *testing.T) { + t.Run("GetDocSessionID", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + var expected string + obj.DocSessionID = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetDocSessionID(), "getter should return the property value") + }) + + t.Run("GetDocSessionID_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaAffectedPagesItemRevision + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetDocSessionID() // Should return zero value + }) + + t.Run("GetPageObjectNumber", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + var expected int + obj.PageObjectNumber = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetPageObjectNumber(), "getter should return the property value") + }) + + t.Run("GetPageObjectNumber_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaAffectedPagesItemRevision + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetPageObjectNumber() // Should return zero value + }) + + t.Run("GetGeneration", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + var expected int + obj.Generation = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetGeneration(), "getter should return the property value") + }) + + t.Run("GetGeneration_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaAffectedPagesItemRevision + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetGeneration() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaAffectedPagesItemRevision(t *testing.T) { + t.Run("SetDocSessionID_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + var fernTestValueDocSessionID string + + // Act + obj.SetDocSessionID(fernTestValueDocSessionID) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetPageObjectNumber_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + var fernTestValuePageObjectNumber int + + // Act + obj.SetPageObjectNumber(fernTestValuePageObjectNumber) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetGeneration_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemRevision{} + var fernTestValueGeneration int + + // Act + obj.SetGeneration(fernTestValueGeneration) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState(t *testing.T) { + t.Run("GetKind", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState{} + var expected string + obj.Kind = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetKind(), "getter should return the property value") + }) + + t.Run("GetKind_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetKind() // Should return zero value + }) + + t.Run("GetUnknown", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState{} + var expected *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + obj.Unknown = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetUnknown(), "getter should return the property value") + }) + + t.Run("GetUnknown_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState{} + obj.Unknown = nil + + // Act & Assert + assert.Nil(t, obj.GetUnknown(), "getter should return nil when property is nil") + }) + + t.Run("GetUnknown_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetUnknown() // Should return zero value + }) + + t.Run("GetKnown", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState{} + var expected *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + obj.Known = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetKnown(), "getter should return the property value") + }) + + t.Run("GetKnown_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState{} + obj.Known = nil + + // Act & Assert + assert.Nil(t, obj.GetKnown(), "getter should return nil when property is nil") + }) + + t.Run("GetKnown_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationState + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetKnown() // Should return zero value + }) + +} + +func TestSettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { + t.Run("SetHasAnyWeakAnnotations", func(t *testing.T) { + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + var fernTestValueHasAnyWeakAnnotations bool + obj.SetHasAnyWeakAnnotations(fernTestValueHasAnyWeakAnnotations) + assert.Equal(t, fernTestValueHasAnyWeakAnnotations, obj.HasAnyWeakAnnotations) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { + t.Run("GetHasAnyWeakAnnotations", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + var expected bool + obj.HasAnyWeakAnnotations = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetHasAnyWeakAnnotations(), "getter should return the property value") + }) + + t.Run("GetHasAnyWeakAnnotations_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetHasAnyWeakAnnotations() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { + t.Run("SetHasAnyWeakAnnotations_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + var fernTestValueHasAnyWeakAnnotations bool + + // Act + obj.SetHasAnyWeakAnnotations(fernTestValueHasAnyWeakAnnotations) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocRedactionsApply200ResponseMetaCacheDelta(t *testing.T) { + t.Run("SetPreviousDocVersion", func(t *testing.T) { + obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + var fernTestValuePreviousDocVersion int + obj.SetPreviousDocVersion(fernTestValuePreviousDocVersion) + assert.Equal(t, fernTestValuePreviousDocVersion, obj.PreviousDocVersion) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetDocVersion", func(t *testing.T) { + obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + var fernTestValueDocVersion int + obj.SetDocVersion(fernTestValueDocVersion) + assert.Equal(t, fernTestValueDocVersion, obj.DocVersion) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetPages", func(t *testing.T) { + obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + var fernTestValuePages []*DocRedactionsApply200ResponseMetaCacheDeltaPagesItem + obj.SetPages(fernTestValuePages) + assert.Equal(t, fernTestValuePages, obj.Pages) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocRedactionsApply200ResponseMetaCacheDelta(t *testing.T) { + t.Run("GetPreviousDocVersion", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + var expected int + obj.PreviousDocVersion = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetPreviousDocVersion(), "getter should return the property value") + }) + + t.Run("GetPreviousDocVersion_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaCacheDelta + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetPreviousDocVersion() // Should return zero value + }) + + t.Run("GetDocVersion", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + var expected int + obj.DocVersion = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetDocVersion(), "getter should return the property value") + }) + + t.Run("GetDocVersion_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaCacheDelta + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetDocVersion() // Should return zero value + }) + + t.Run("GetPages", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + var expected []*DocRedactionsApply200ResponseMetaCacheDeltaPagesItem + obj.Pages = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetPages(), "getter should return the property value") + }) + + t.Run("GetPages_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + obj.Pages = nil + + // Act & Assert + assert.Nil(t, obj.GetPages(), "getter should return nil when property is nil") + }) + + t.Run("GetPages_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaCacheDelta + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetPages() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaCacheDelta(t *testing.T) { + t.Run("SetPreviousDocVersion_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + var fernTestValuePreviousDocVersion int + + // Act + obj.SetPreviousDocVersion(fernTestValuePreviousDocVersion) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetDocVersion_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + var fernTestValueDocVersion int + + // Act + obj.SetDocVersion(fernTestValueDocVersion) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetPages_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaCacheDelta{} + var fernTestValuePages []*DocRedactionsApply200ResponseMetaCacheDeltaPagesItem + + // Act + obj.SetPages(fernTestValuePages) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItem(t *testing.T) { + t.Run("SetPageObjectNumber", func(t *testing.T) { + obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItem{} + var fernTestValuePageObjectNumber int + obj.SetPageObjectNumber(fernTestValuePageObjectNumber) + assert.Equal(t, fernTestValuePageObjectNumber, obj.PageObjectNumber) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetCache", func(t *testing.T) { + obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItem{} + var fernTestValueCache *DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache + obj.SetCache(fernTestValueCache) + assert.Equal(t, fernTestValueCache, obj.Cache) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItem(t *testing.T) { + t.Run("GetPageObjectNumber", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItem{} + var expected int + obj.PageObjectNumber = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetPageObjectNumber(), "getter should return the property value") + }) + + t.Run("GetPageObjectNumber_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaCacheDeltaPagesItem + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetPageObjectNumber() // Should return zero value + }) + + t.Run("GetCache", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItem{} + var expected *DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache + obj.Cache = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetCache(), "getter should return the property value") + }) + + t.Run("GetCache_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItem{} + obj.Cache = nil + + // Act & Assert + assert.Nil(t, obj.GetCache(), "getter should return nil when property is nil") + }) + + t.Run("GetCache_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaCacheDeltaPagesItem + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetCache() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaCacheDeltaPagesItem(t *testing.T) { + t.Run("SetPageObjectNumber_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItem{} + var fernTestValuePageObjectNumber int + + // Act + obj.SetPageObjectNumber(fernTestValuePageObjectNumber) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetCache_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItem{} + var fernTestValueCache *DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache + + // Act + obj.SetCache(fernTestValueCache) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { + t.Run("SetContentVersion", func(t *testing.T) { + obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache{} + var fernTestValueContentVersion int + obj.SetContentVersion(fernTestValueContentVersion) + assert.Equal(t, fernTestValueContentVersion, obj.ContentVersion) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetAnnotationVersion", func(t *testing.T) { + obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache{} + var fernTestValueAnnotationVersion int + obj.SetAnnotationVersion(fernTestValueAnnotationVersion) + assert.Equal(t, fernTestValueAnnotationVersion, obj.AnnotationVersion) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { + t.Run("GetContentVersion", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache{} + var expected int + obj.ContentVersion = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetContentVersion(), "getter should return the property value") + }) + + t.Run("GetContentVersion_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetContentVersion() // Should return zero value + }) + + t.Run("GetAnnotationVersion", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache{} + var expected int + obj.AnnotationVersion = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetAnnotationVersion(), "getter should return the property value") + }) + + t.Run("GetAnnotationVersion_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetAnnotationVersion() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { + t.Run("SetContentVersion_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache{} + var fernTestValueContentVersion int + + // Act + obj.SetContentVersion(fernTestValueContentVersion) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetAnnotationVersion_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply200ResponseMetaCacheDeltaPagesItemCache{} + var fernTestValueAnnotationVersion int + + // Act + obj.SetAnnotationVersion(fernTestValueAnnotationVersion) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocRedactionsApply400Response(t *testing.T) { + t.Run("SetName", func(t *testing.T) { + obj := &DocRedactionsApply400Response{} + var fernTestValueName DocRedactionsApply400ResponseName + obj.SetName(fernTestValueName) + assert.Equal(t, fernTestValueName, obj.Name) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetCode", func(t *testing.T) { + obj := &DocRedactionsApply400Response{} + var fernTestValueCode DocRedactionsApply400ResponseCode + obj.SetCode(fernTestValueCode) + assert.Equal(t, fernTestValueCode, obj.Code) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetMessage", func(t *testing.T) { + obj := &DocRedactionsApply400Response{} + var fernTestValueMessage string + obj.SetMessage(fernTestValueMessage) + assert.Equal(t, fernTestValueMessage, obj.Message) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetDetails", func(t *testing.T) { + obj := &DocRedactionsApply400Response{} + var fernTestValueDetails map[string]any + obj.SetDetails(fernTestValueDetails) + assert.Equal(t, fernTestValueDetails, obj.Details) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocRedactionsApply400Response(t *testing.T) { + t.Run("GetName", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply400Response{} + var expected DocRedactionsApply400ResponseName + obj.Name = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetName(), "getter should return the property value") + }) + + t.Run("GetName_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply400Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetName() // Should return zero value + }) + + t.Run("GetCode", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply400Response{} + var expected DocRedactionsApply400ResponseCode + obj.Code = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetCode(), "getter should return the property value") + }) + + t.Run("GetCode_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply400Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetCode() // Should return zero value + }) + + t.Run("GetMessage", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply400Response{} + var expected string + obj.Message = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetMessage(), "getter should return the property value") + }) + + t.Run("GetMessage_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply400Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetMessage() // Should return zero value + }) + + t.Run("GetDetails", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply400Response{} + var expected map[string]any + obj.Details = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetDetails(), "getter should return the property value") + }) + + t.Run("GetDetails_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply400Response{} + obj.Details = nil + + // Act & Assert + assert.Nil(t, obj.GetDetails(), "getter should return nil when property is nil") + }) + + t.Run("GetDetails_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply400Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetDetails() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocRedactionsApply400Response(t *testing.T) { + t.Run("SetName_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply400Response{} + var fernTestValueName DocRedactionsApply400ResponseName + + // Act + obj.SetName(fernTestValueName) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetCode_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply400Response{} + var fernTestValueCode DocRedactionsApply400ResponseCode + + // Act + obj.SetCode(fernTestValueCode) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetMessage_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply400Response{} + var fernTestValueMessage string + + // Act + obj.SetMessage(fernTestValueMessage) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetDetails_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply400Response{} + var fernTestValueDetails map[string]any + + // Act + obj.SetDetails(fernTestValueDetails) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocRedactionsApply404Response(t *testing.T) { + t.Run("SetName", func(t *testing.T) { + obj := &DocRedactionsApply404Response{} + var fernTestValueName DocRedactionsApply404ResponseName + obj.SetName(fernTestValueName) + assert.Equal(t, fernTestValueName, obj.Name) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetCode", func(t *testing.T) { + obj := &DocRedactionsApply404Response{} + var fernTestValueCode DocRedactionsApply404ResponseCode + obj.SetCode(fernTestValueCode) + assert.Equal(t, fernTestValueCode, obj.Code) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetMessage", func(t *testing.T) { + obj := &DocRedactionsApply404Response{} + var fernTestValueMessage string + obj.SetMessage(fernTestValueMessage) + assert.Equal(t, fernTestValueMessage, obj.Message) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetDetails", func(t *testing.T) { + obj := &DocRedactionsApply404Response{} + var fernTestValueDetails map[string]any + obj.SetDetails(fernTestValueDetails) + assert.Equal(t, fernTestValueDetails, obj.Details) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocRedactionsApply404Response(t *testing.T) { + t.Run("GetName", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply404Response{} + var expected DocRedactionsApply404ResponseName + obj.Name = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetName(), "getter should return the property value") + }) + + t.Run("GetName_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply404Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetName() // Should return zero value + }) + + t.Run("GetCode", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply404Response{} + var expected DocRedactionsApply404ResponseCode + obj.Code = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetCode(), "getter should return the property value") + }) + + t.Run("GetCode_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply404Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetCode() // Should return zero value + }) + + t.Run("GetMessage", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply404Response{} + var expected string + obj.Message = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetMessage(), "getter should return the property value") + }) + + t.Run("GetMessage_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply404Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetMessage() // Should return zero value + }) + + t.Run("GetDetails", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply404Response{} + var expected map[string]any + obj.Details = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetDetails(), "getter should return the property value") + }) + + t.Run("GetDetails_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply404Response{} + obj.Details = nil + + // Act & Assert + assert.Nil(t, obj.GetDetails(), "getter should return nil when property is nil") + }) + + t.Run("GetDetails_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRedactionsApply404Response + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetDetails() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocRedactionsApply404Response(t *testing.T) { + t.Run("SetName_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply404Response{} + var fernTestValueName DocRedactionsApply404ResponseName + + // Act + obj.SetName(fernTestValueName) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetCode_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply404Response{} + var fernTestValueCode DocRedactionsApply404ResponseCode + + // Act + obj.SetCode(fernTestValueCode) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetMessage_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply404Response{} + var fernTestValueMessage string + + // Act + obj.SetMessage(fernTestValueMessage) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + + t.Run("SetDetails_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRedactionsApply404Response{} + var fernTestValueDetails map[string]any + + // Act + obj.SetDetails(fernTestValueDetails) + + // Assert - object with explicitly set field can be marshaled/unmarshaled + bytes, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed for test setup") + + // This test ensures JSON marshaling and unmarshaling succeed when the field has a zero/nil value + // Detect if marshaled JSON is an object or primitive to use correct unmarshal target + if len(bytes) > 0 && bytes[0] == '{' { + // JSON object - unmarshal into map + var unmarshaled map[string]interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } else { + // JSON primitive (string, number, boolean, null) - unmarshal into interface{} + var unmarshaled interface{} + err = json.Unmarshal(bytes, &unmarshaled) + require.NoError(t, err, "unmarshaling should succeed for test verification") + } + + // Note: This does not explicitly assert the presence of a specific JSON field + // It verifies that setting a field via setter allows successful JSON round-trip + }) + +} + +func TestSettersDocRenderResponse(t *testing.T) { + t.Run("SetName", func(t *testing.T) { + obj := &DocRenderResponse{} + var fernTestValueName DocRenderResponseName + obj.SetName(fernTestValueName) + assert.Equal(t, fernTestValueName, obj.Name) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetCode", func(t *testing.T) { + obj := &DocRenderResponse{} + var fernTestValueCode DocRenderResponseCode + obj.SetCode(fernTestValueCode) + assert.Equal(t, fernTestValueCode, obj.Code) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetMessage", func(t *testing.T) { + obj := &DocRenderResponse{} + var fernTestValueMessage string + obj.SetMessage(fernTestValueMessage) + assert.Equal(t, fernTestValueMessage, obj.Message) + assert.NotNil(t, obj.explicitFields) + }) + + t.Run("SetDetails", func(t *testing.T) { + obj := &DocRenderResponse{} + var fernTestValueDetails map[string]any + obj.SetDetails(fernTestValueDetails) + assert.Equal(t, fernTestValueDetails, obj.Details) + assert.NotNil(t, obj.explicitFields) + }) + +} + +func TestGettersDocRenderResponse(t *testing.T) { + t.Run("GetName", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRenderResponse{} + var expected DocRenderResponseName + obj.Name = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetName(), "getter should return the property value") + }) + + t.Run("GetName_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRenderResponse + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetName() // Should return zero value + }) + + t.Run("GetCode", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRenderResponse{} + var expected DocRenderResponseCode + obj.Code = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetCode(), "getter should return the property value") + }) + + t.Run("GetCode_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRenderResponse + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetCode() // Should return zero value + }) + + t.Run("GetMessage", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRenderResponse{} + var expected string + obj.Message = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetMessage(), "getter should return the property value") + }) + + t.Run("GetMessage_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRenderResponse + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetMessage() // Should return zero value + }) + + t.Run("GetDetails", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRenderResponse{} + var expected map[string]any + obj.Details = expected + + // Act & Assert + assert.Equal(t, expected, obj.GetDetails(), "getter should return the property value") + }) + + t.Run("GetDetails_NilValue", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRenderResponse{} + obj.Details = nil + + // Act & Assert + assert.Nil(t, obj.GetDetails(), "getter should return nil when property is nil") + }) + + t.Run("GetDetails_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocRenderResponse + // Should not panic - getters should handle nil receiver gracefully + defer func() { + if r := recover(); r != nil { + t.Errorf("Getter panicked on nil receiver: %v", r) + } + }() + _ = obj.GetDetails() // Should return zero value + }) + +} + +func TestSettersMarkExplicitDocRenderResponse(t *testing.T) { + t.Run("SetName_MarksExplicit", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocRenderResponse{} + var fernTestValueName DocRenderResponseName + + // Act + obj.SetName(fernTestValueName) // Assert - object with explicitly set field can be marshaled/unmarshaled bytes, err := json.Marshal(obj) @@ -333621,6 +337799,72 @@ func TestJSONMarshalingDocPagesDelete404Response(t *testing.T) { }) } +func TestJSONMarshalingDocPagesExtract400Response(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract400Response{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesExtract400Response + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesExtract400Response + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesExtract400Response + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesExtract404Response(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesExtract404Response{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesExtract404Response + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesExtract404Response + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesExtract404Response + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + func TestJSONMarshalingDocPagesFlatten200Response(t *testing.T) { t.Run("MarshalUnmarshal", func(t *testing.T) { t.Parallel() @@ -333984,6 +338228,732 @@ func TestJSONMarshalingDocPagesFlatten404Response(t *testing.T) { }) } +func TestJSONMarshalingDocPagesInsert200Response(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsert200Response{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsert200Response + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200Response + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200Response + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsert200ResponseMeta(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsert200ResponseMeta{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsert200ResponseMeta + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200ResponseMeta + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200ResponseMeta + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsert200ResponseMetaAffectedPagesItem(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsert200ResponseMetaAffectedPagesItem{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsert200ResponseMetaAffectedPagesItem + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200ResponseMetaAffectedPagesItem + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200ResponseMetaAffectedPagesItem + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsert200ResponseMetaAffectedPagesItemRevision(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemRevision{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsert200ResponseMetaAffectedPagesItemRevision + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200ResponseMetaAffectedPagesItemRevision + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200ResponseMetaAffectedPagesItemRevision + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsert200ResponseMetaCacheDelta(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsert200ResponseMetaCacheDelta{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsert200ResponseMetaCacheDelta + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200ResponseMetaCacheDelta + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200ResponseMetaCacheDelta + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsert200ResponseMetaCacheDeltaPagesItem(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItem{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsert200ResponseMetaCacheDeltaPagesItem + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200ResponseMetaCacheDeltaPagesItem + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200ResponseMetaCacheDeltaPagesItem + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsert200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsert400Response(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsert400Response{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsert400Response + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert400Response + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert400Response + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsert404Response(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsert404Response{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsert404Response + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert404Response + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsert404Response + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsertBlank200Response(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsertBlank200Response{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsertBlank200Response + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200Response + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200Response + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsertBlank200ResponseMeta(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsertBlank200ResponseMeta{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsertBlank200ResponseMeta + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200ResponseMeta + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200ResponseMeta + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsertBlank200ResponseMetaAffectedPagesItem(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItem{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsertBlank200ResponseMetaAffectedPagesItem + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200ResponseMetaAffectedPagesItem + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200ResponseMetaAffectedPagesItem + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsertBlank200ResponseMetaCacheDelta(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsertBlank200ResponseMetaCacheDelta{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsertBlank200ResponseMetaCacheDelta + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200ResponseMetaCacheDelta + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200ResponseMetaCacheDelta + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsertBlank400Response(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsertBlank400Response{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsertBlank400Response + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank400Response + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank400Response + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + +func TestJSONMarshalingDocPagesInsertBlank404Response(t *testing.T) { + t.Run("MarshalUnmarshal", func(t *testing.T) { + t.Parallel() + // Arrange + obj := &DocPagesInsertBlank404Response{} + + // Act - Marshal to JSON + data, err := json.Marshal(obj) + require.NoError(t, err, "marshaling should succeed") + assert.NotNil(t, data, "marshaled data should not be nil") + assert.NotEmpty(t, data, "marshaled data should not be empty") + + // Unmarshal back and verify round-trip + var unmarshaled DocPagesInsertBlank404Response + err = json.Unmarshal(data, &unmarshaled) + assert.NoError(t, err, "round-trip unmarshal should succeed") + }) + + t.Run("UnmarshalInvalidJSON", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank404Response + err := json.Unmarshal([]byte(`{invalid json}`), &obj) + assert.Error(t, err, "unmarshaling invalid JSON should return an error") + }) + + t.Run("UnmarshalEmptyObject", func(t *testing.T) { + t.Parallel() + var obj DocPagesInsertBlank404Response + err := json.Unmarshal([]byte(`{}`), &obj) + assert.NoError(t, err, "unmarshaling empty object should succeed") + }) +} + func TestJSONMarshalingDocPagesMove200Response(t *testing.T) { t.Run("MarshalUnmarshal", func(t *testing.T) { t.Parallel() @@ -353976,6 +358946,38 @@ func TestStringDocPagesDelete404Response(t *testing.T) { }) } +func TestStringDocPagesExtract400Response(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesExtract400Response{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesExtract400Response + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesExtract404Response(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesExtract404Response{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesExtract404Response + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + func TestStringDocPagesFlatten200Response(t *testing.T) { t.Run("StringMethod", func(t *testing.T) { t.Parallel() @@ -354152,6 +359154,358 @@ func TestStringDocPagesFlatten404Response(t *testing.T) { }) } +func TestStringDocPagesInsert200Response(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200Response{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200Response + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsert200ResponseMeta(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200ResponseMeta{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200ResponseMeta + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsert200ResponseMetaAffectedPagesItem(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200ResponseMetaAffectedPagesItem{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200ResponseMetaAffectedPagesItem + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsert200ResponseMetaAffectedPagesItemRevision(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemRevision{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200ResponseMetaAffectedPagesItemRevision + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsert200ResponseMetaCacheDelta(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200ResponseMetaCacheDelta{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200ResponseMetaCacheDelta + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsert200ResponseMetaCacheDeltaPagesItem(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItem{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200ResponseMetaCacheDeltaPagesItem + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsert200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsert400Response(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert400Response{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert400Response + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsert404Response(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert404Response{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert404Response + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsertBlank200Response(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200Response{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200Response + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsertBlank200ResponseMeta(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200ResponseMeta{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200ResponseMeta + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsertBlank200ResponseMetaAffectedPagesItem(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItem{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItem + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsertBlank200ResponseMetaCacheDelta(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200ResponseMetaCacheDelta{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200ResponseMetaCacheDelta + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsertBlank400Response(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank400Response{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank400Response + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + +func TestStringDocPagesInsertBlank404Response(t *testing.T) { + t.Run("StringMethod", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank404Response{} + result := obj.String() + assert.NotEmpty(t, result, "String() should return a non-empty representation") + }) + + t.Run("StringMethod_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank404Response + result := obj.String() + assert.Equal(t, "", result, "String() should return for nil receiver") + }) +} + func TestStringDocPagesMove200Response(t *testing.T) { t.Run("StringMethod", func(t *testing.T) { t.Parallel() @@ -408954,6 +414308,346 @@ func TestEnumDocPagesDelete404ResponseName(t *testing.T) { }) } +func TestEnumDocPagesExtract400ResponseCode(t *testing.T) { + t.Run("NewFromString_Unknown", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("Unknown") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("Unknown"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_InvalidArg", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("InvalidArg") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("InvalidArg"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocNotOpen", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("DocNotOpen") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("DocNotOpen"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocOpenFailed", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("DocOpenFailed") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("DocOpenFailed"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocPasswordRequired", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("DocPasswordRequired") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("DocPasswordRequired"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocPasswordIncorrect", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("DocPasswordIncorrect") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("DocPasswordIncorrect"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_SharePasswordRequired", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("SharePasswordRequired") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("SharePasswordRequired"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Aborted", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("Aborted") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("Aborted"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Network", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("Network") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("Network"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Unauthenticated", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("Unauthenticated") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("Unauthenticated"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Forbidden", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("Forbidden") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("Forbidden"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_NotFound", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("NotFound") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("NotFound"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_WireFormat", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("WireFormat") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("WireFormat"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_RuntimeUnavailable", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("RuntimeUnavailable") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("RuntimeUnavailable"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_InvalidReference", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("InvalidReference") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("InvalidReference"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_WeakAnnotationSessionConflict", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("WeakAnnotationSessionConflict") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("WeakAnnotationSessionConflict"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_LayerVersionConflict", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("LayerVersionConflict") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("LayerVersionConflict"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_NotImplemented", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("NotImplemented") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("NotImplemented"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_MalformedPdf", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseCodeFromString("MalformedPdf") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseCode("MalformedPdf"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Invalid", func(t *testing.T) { + _, err := NewDocPagesExtract400ResponseCodeFromString("invalid_value_that_does_not_exist") + assert.Error(t, err) + }) + + t.Run("Ptr", func(t *testing.T) { + val, err := NewDocPagesExtract400ResponseCodeFromString("Unknown") + assert.NoError(t, err) + ptr := val.Ptr() + assert.NotNil(t, ptr) + assert.Equal(t, val, *ptr) + }) +} + +func TestEnumDocPagesExtract400ResponseName(t *testing.T) { + t.Run("NewFromString_EngineError", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract400ResponseNameFromString("EngineError") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract400ResponseName("EngineError"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Invalid", func(t *testing.T) { + _, err := NewDocPagesExtract400ResponseNameFromString("invalid_value_that_does_not_exist") + assert.Error(t, err) + }) + + t.Run("Ptr", func(t *testing.T) { + val, err := NewDocPagesExtract400ResponseNameFromString("EngineError") + assert.NoError(t, err) + ptr := val.Ptr() + assert.NotNil(t, ptr) + assert.Equal(t, val, *ptr) + }) +} + +func TestEnumDocPagesExtract404ResponseCode(t *testing.T) { + t.Run("NewFromString_Unknown", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("Unknown") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("Unknown"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_InvalidArg", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("InvalidArg") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("InvalidArg"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocNotOpen", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("DocNotOpen") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("DocNotOpen"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocOpenFailed", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("DocOpenFailed") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("DocOpenFailed"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocPasswordRequired", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("DocPasswordRequired") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("DocPasswordRequired"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocPasswordIncorrect", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("DocPasswordIncorrect") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("DocPasswordIncorrect"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_SharePasswordRequired", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("SharePasswordRequired") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("SharePasswordRequired"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Aborted", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("Aborted") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("Aborted"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Network", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("Network") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("Network"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Unauthenticated", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("Unauthenticated") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("Unauthenticated"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Forbidden", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("Forbidden") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("Forbidden"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_NotFound", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("NotFound") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("NotFound"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_WireFormat", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("WireFormat") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("WireFormat"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_RuntimeUnavailable", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("RuntimeUnavailable") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("RuntimeUnavailable"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_InvalidReference", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("InvalidReference") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("InvalidReference"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_WeakAnnotationSessionConflict", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("WeakAnnotationSessionConflict") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("WeakAnnotationSessionConflict"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_LayerVersionConflict", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("LayerVersionConflict") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("LayerVersionConflict"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_NotImplemented", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("NotImplemented") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("NotImplemented"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_MalformedPdf", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseCodeFromString("MalformedPdf") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseCode("MalformedPdf"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Invalid", func(t *testing.T) { + _, err := NewDocPagesExtract404ResponseCodeFromString("invalid_value_that_does_not_exist") + assert.Error(t, err) + }) + + t.Run("Ptr", func(t *testing.T) { + val, err := NewDocPagesExtract404ResponseCodeFromString("Unknown") + assert.NoError(t, err) + ptr := val.Ptr() + assert.NotNil(t, ptr) + assert.Equal(t, val, *ptr) + }) +} + +func TestEnumDocPagesExtract404ResponseName(t *testing.T) { + t.Run("NewFromString_EngineError", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesExtract404ResponseNameFromString("EngineError") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesExtract404ResponseName("EngineError"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Invalid", func(t *testing.T) { + _, err := NewDocPagesExtract404ResponseNameFromString("invalid_value_that_does_not_exist") + assert.Error(t, err) + }) + + t.Run("Ptr", func(t *testing.T) { + val, err := NewDocPagesExtract404ResponseNameFromString("EngineError") + assert.NoError(t, err) + ptr := val.Ptr() + assert.NotNil(t, ptr) + assert.Equal(t, val, *ptr) + }) +} + func TestEnumDocPagesFlatten400ResponseCode(t *testing.T) { t.Run("NewFromString_Unknown", func(t *testing.T) { t.Parallel() @@ -409294,6 +414988,686 @@ func TestEnumDocPagesFlatten404ResponseName(t *testing.T) { }) } +func TestEnumDocPagesInsert400ResponseCode(t *testing.T) { + t.Run("NewFromString_Unknown", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("Unknown") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("Unknown"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_InvalidArg", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("InvalidArg") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("InvalidArg"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocNotOpen", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("DocNotOpen") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("DocNotOpen"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocOpenFailed", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("DocOpenFailed") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("DocOpenFailed"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocPasswordRequired", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("DocPasswordRequired") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("DocPasswordRequired"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocPasswordIncorrect", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("DocPasswordIncorrect") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("DocPasswordIncorrect"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_SharePasswordRequired", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("SharePasswordRequired") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("SharePasswordRequired"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Aborted", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("Aborted") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("Aborted"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Network", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("Network") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("Network"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Unauthenticated", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("Unauthenticated") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("Unauthenticated"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Forbidden", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("Forbidden") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("Forbidden"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_NotFound", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("NotFound") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("NotFound"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_WireFormat", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("WireFormat") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("WireFormat"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_RuntimeUnavailable", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("RuntimeUnavailable") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("RuntimeUnavailable"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_InvalidReference", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("InvalidReference") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("InvalidReference"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_WeakAnnotationSessionConflict", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("WeakAnnotationSessionConflict") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("WeakAnnotationSessionConflict"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_LayerVersionConflict", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("LayerVersionConflict") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("LayerVersionConflict"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_NotImplemented", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("NotImplemented") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("NotImplemented"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_MalformedPdf", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseCodeFromString("MalformedPdf") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseCode("MalformedPdf"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Invalid", func(t *testing.T) { + _, err := NewDocPagesInsert400ResponseCodeFromString("invalid_value_that_does_not_exist") + assert.Error(t, err) + }) + + t.Run("Ptr", func(t *testing.T) { + val, err := NewDocPagesInsert400ResponseCodeFromString("Unknown") + assert.NoError(t, err) + ptr := val.Ptr() + assert.NotNil(t, ptr) + assert.Equal(t, val, *ptr) + }) +} + +func TestEnumDocPagesInsert400ResponseName(t *testing.T) { + t.Run("NewFromString_EngineError", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert400ResponseNameFromString("EngineError") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert400ResponseName("EngineError"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Invalid", func(t *testing.T) { + _, err := NewDocPagesInsert400ResponseNameFromString("invalid_value_that_does_not_exist") + assert.Error(t, err) + }) + + t.Run("Ptr", func(t *testing.T) { + val, err := NewDocPagesInsert400ResponseNameFromString("EngineError") + assert.NoError(t, err) + ptr := val.Ptr() + assert.NotNil(t, ptr) + assert.Equal(t, val, *ptr) + }) +} + +func TestEnumDocPagesInsert404ResponseCode(t *testing.T) { + t.Run("NewFromString_Unknown", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("Unknown") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("Unknown"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_InvalidArg", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("InvalidArg") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("InvalidArg"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocNotOpen", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("DocNotOpen") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("DocNotOpen"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocOpenFailed", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("DocOpenFailed") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("DocOpenFailed"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocPasswordRequired", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("DocPasswordRequired") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("DocPasswordRequired"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocPasswordIncorrect", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("DocPasswordIncorrect") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("DocPasswordIncorrect"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_SharePasswordRequired", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("SharePasswordRequired") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("SharePasswordRequired"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Aborted", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("Aborted") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("Aborted"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Network", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("Network") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("Network"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Unauthenticated", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("Unauthenticated") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("Unauthenticated"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Forbidden", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("Forbidden") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("Forbidden"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_NotFound", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("NotFound") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("NotFound"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_WireFormat", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("WireFormat") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("WireFormat"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_RuntimeUnavailable", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("RuntimeUnavailable") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("RuntimeUnavailable"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_InvalidReference", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("InvalidReference") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("InvalidReference"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_WeakAnnotationSessionConflict", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("WeakAnnotationSessionConflict") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("WeakAnnotationSessionConflict"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_LayerVersionConflict", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("LayerVersionConflict") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("LayerVersionConflict"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_NotImplemented", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("NotImplemented") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("NotImplemented"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_MalformedPdf", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseCodeFromString("MalformedPdf") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseCode("MalformedPdf"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Invalid", func(t *testing.T) { + _, err := NewDocPagesInsert404ResponseCodeFromString("invalid_value_that_does_not_exist") + assert.Error(t, err) + }) + + t.Run("Ptr", func(t *testing.T) { + val, err := NewDocPagesInsert404ResponseCodeFromString("Unknown") + assert.NoError(t, err) + ptr := val.Ptr() + assert.NotNil(t, ptr) + assert.Equal(t, val, *ptr) + }) +} + +func TestEnumDocPagesInsert404ResponseName(t *testing.T) { + t.Run("NewFromString_EngineError", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsert404ResponseNameFromString("EngineError") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsert404ResponseName("EngineError"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Invalid", func(t *testing.T) { + _, err := NewDocPagesInsert404ResponseNameFromString("invalid_value_that_does_not_exist") + assert.Error(t, err) + }) + + t.Run("Ptr", func(t *testing.T) { + val, err := NewDocPagesInsert404ResponseNameFromString("EngineError") + assert.NoError(t, err) + ptr := val.Ptr() + assert.NotNil(t, ptr) + assert.Equal(t, val, *ptr) + }) +} + +func TestEnumDocPagesInsertBlank400ResponseCode(t *testing.T) { + t.Run("NewFromString_Unknown", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("Unknown") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("Unknown"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_InvalidArg", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("InvalidArg") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("InvalidArg"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocNotOpen", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("DocNotOpen") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("DocNotOpen"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocOpenFailed", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("DocOpenFailed") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("DocOpenFailed"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocPasswordRequired", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("DocPasswordRequired") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("DocPasswordRequired"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocPasswordIncorrect", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("DocPasswordIncorrect") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("DocPasswordIncorrect"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_SharePasswordRequired", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("SharePasswordRequired") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("SharePasswordRequired"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Aborted", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("Aborted") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("Aborted"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Network", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("Network") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("Network"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Unauthenticated", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("Unauthenticated") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("Unauthenticated"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Forbidden", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("Forbidden") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("Forbidden"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_NotFound", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("NotFound") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("NotFound"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_WireFormat", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("WireFormat") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("WireFormat"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_RuntimeUnavailable", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("RuntimeUnavailable") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("RuntimeUnavailable"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_InvalidReference", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("InvalidReference") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("InvalidReference"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_WeakAnnotationSessionConflict", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("WeakAnnotationSessionConflict") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("WeakAnnotationSessionConflict"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_LayerVersionConflict", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("LayerVersionConflict") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("LayerVersionConflict"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_NotImplemented", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("NotImplemented") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("NotImplemented"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_MalformedPdf", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("MalformedPdf") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseCode("MalformedPdf"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Invalid", func(t *testing.T) { + _, err := NewDocPagesInsertBlank400ResponseCodeFromString("invalid_value_that_does_not_exist") + assert.Error(t, err) + }) + + t.Run("Ptr", func(t *testing.T) { + val, err := NewDocPagesInsertBlank400ResponseCodeFromString("Unknown") + assert.NoError(t, err) + ptr := val.Ptr() + assert.NotNil(t, ptr) + assert.Equal(t, val, *ptr) + }) +} + +func TestEnumDocPagesInsertBlank400ResponseName(t *testing.T) { + t.Run("NewFromString_EngineError", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank400ResponseNameFromString("EngineError") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank400ResponseName("EngineError"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Invalid", func(t *testing.T) { + _, err := NewDocPagesInsertBlank400ResponseNameFromString("invalid_value_that_does_not_exist") + assert.Error(t, err) + }) + + t.Run("Ptr", func(t *testing.T) { + val, err := NewDocPagesInsertBlank400ResponseNameFromString("EngineError") + assert.NoError(t, err) + ptr := val.Ptr() + assert.NotNil(t, ptr) + assert.Equal(t, val, *ptr) + }) +} + +func TestEnumDocPagesInsertBlank404ResponseCode(t *testing.T) { + t.Run("NewFromString_Unknown", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("Unknown") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("Unknown"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_InvalidArg", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("InvalidArg") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("InvalidArg"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocNotOpen", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("DocNotOpen") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("DocNotOpen"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocOpenFailed", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("DocOpenFailed") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("DocOpenFailed"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocPasswordRequired", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("DocPasswordRequired") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("DocPasswordRequired"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_DocPasswordIncorrect", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("DocPasswordIncorrect") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("DocPasswordIncorrect"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_SharePasswordRequired", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("SharePasswordRequired") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("SharePasswordRequired"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Aborted", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("Aborted") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("Aborted"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Network", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("Network") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("Network"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Unauthenticated", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("Unauthenticated") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("Unauthenticated"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Forbidden", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("Forbidden") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("Forbidden"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_NotFound", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("NotFound") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("NotFound"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_WireFormat", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("WireFormat") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("WireFormat"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_RuntimeUnavailable", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("RuntimeUnavailable") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("RuntimeUnavailable"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_InvalidReference", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("InvalidReference") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("InvalidReference"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_WeakAnnotationSessionConflict", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("WeakAnnotationSessionConflict") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("WeakAnnotationSessionConflict"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_LayerVersionConflict", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("LayerVersionConflict") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("LayerVersionConflict"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_NotImplemented", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("NotImplemented") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("NotImplemented"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_MalformedPdf", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("MalformedPdf") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseCode("MalformedPdf"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Invalid", func(t *testing.T) { + _, err := NewDocPagesInsertBlank404ResponseCodeFromString("invalid_value_that_does_not_exist") + assert.Error(t, err) + }) + + t.Run("Ptr", func(t *testing.T) { + val, err := NewDocPagesInsertBlank404ResponseCodeFromString("Unknown") + assert.NoError(t, err) + ptr := val.Ptr() + assert.NotNil(t, ptr) + assert.Equal(t, val, *ptr) + }) +} + +func TestEnumDocPagesInsertBlank404ResponseName(t *testing.T) { + t.Run("NewFromString_EngineError", func(t *testing.T) { + t.Parallel() + val, err := NewDocPagesInsertBlank404ResponseNameFromString("EngineError") + assert.NoError(t, err, "valid enum value should not return error") + assert.Equal(t, DocPagesInsertBlank404ResponseName("EngineError"), val, "enum value should match expected wire value") + }) + + t.Run("NewFromString_Invalid", func(t *testing.T) { + _, err := NewDocPagesInsertBlank404ResponseNameFromString("invalid_value_that_does_not_exist") + assert.Error(t, err) + }) + + t.Run("Ptr", func(t *testing.T) { + val, err := NewDocPagesInsertBlank404ResponseNameFromString("EngineError") + assert.NoError(t, err) + ptr := val.Ptr() + assert.NotNil(t, ptr) + assert.Equal(t, val, *ptr) + }) +} + func TestEnumDocPagesMove400ResponseCode(t *testing.T) { t.Run("NewFromString_Unknown", func(t *testing.T) { t.Parallel() @@ -433992,6 +440366,52 @@ func TestExtraPropertiesDocPagesDelete404Response(t *testing.T) { }) } +func TestExtraPropertiesDocPagesExtract400Response(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesExtract400Response{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesExtract400Response + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesExtract404Response(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesExtract404Response{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesExtract404Response + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + func TestExtraPropertiesDocPagesFlatten200Response(t *testing.T) { t.Run("GetExtraProperties", func(t *testing.T) { t.Parallel() @@ -434245,6 +440665,512 @@ func TestExtraPropertiesDocPagesFlatten404Response(t *testing.T) { }) } +func TestExtraPropertiesDocPagesInsert200Response(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200Response{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200Response + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsert200ResponseMeta(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200ResponseMeta{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200ResponseMeta + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsert200ResponseMetaAffectedPagesItem(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200ResponseMetaAffectedPagesItem{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200ResponseMetaAffectedPagesItem + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsert200ResponseMetaAffectedPagesItemRevision(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemRevision{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200ResponseMetaAffectedPagesItemRevision + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsert200ResponseMetaCacheDelta(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200ResponseMetaCacheDelta{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200ResponseMetaCacheDelta + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsert200ResponseMetaCacheDeltaPagesItem(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItem{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200ResponseMetaCacheDeltaPagesItem + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsert200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert200ResponseMetaCacheDeltaPagesItemCache + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsert400Response(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert400Response{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert400Response + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsert404Response(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsert404Response{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsert404Response + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsertBlank200Response(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200Response{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200Response + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsertBlank200ResponseMeta(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200ResponseMeta{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200ResponseMeta + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsertBlank200ResponseMetaAffectedPagesItem(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItem{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItem + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItemRevision + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateKnown + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200ResponseMetaAffectedPagesItemWeakAnnotationStateUnknown + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsertBlank200ResponseMetaCacheDelta(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200ResponseMetaCacheDelta{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200ResponseMetaCacheDelta + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItem + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank200ResponseMetaCacheDeltaPagesItemCache + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsertBlank400Response(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank400Response{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank400Response + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + +func TestExtraPropertiesDocPagesInsertBlank404Response(t *testing.T) { + t.Run("GetExtraProperties", func(t *testing.T) { + t.Parallel() + obj := &DocPagesInsertBlank404Response{} + // Should not panic when calling GetExtraProperties() + defer func() { + if r := recover(); r != nil { + t.Errorf("GetExtraProperties() panicked: %v", r) + } + }() + extraProps := obj.GetExtraProperties() + // Result can be nil or an empty/non-empty map + _ = extraProps + }) + + t.Run("GetExtraProperties_NilReceiver", func(t *testing.T) { + t.Parallel() + var obj *DocPagesInsertBlank404Response + extraProps := obj.GetExtraProperties() + assert.Nil(t, extraProps, "nil receiver should return nil without panicking") + }) +} + func TestExtraPropertiesDocPagesMove200Response(t *testing.T) { t.Run("GetExtraProperties", func(t *testing.T) { t.Parallel() diff --git a/wiremock/wiremock-mappings.json b/wiremock/wiremock-mappings.json index 1979f95..0f13b52 100644 --- a/wiremock/wiremock-mappings.json +++ b/wiremock/wiremock-mappings.json @@ -1558,6 +1558,45 @@ } } }, + { + "id": "53b73685-826d-4bfc-bdfe-73f37c3c7451", + "name": "Export the listed pages, in order, as a standalone PDF. - default", + "request": { + "urlPathTemplate": "/v1/docs/{docId}/layers/{layerName}/pages/extract", + "method": "POST", + "headers": { + "Authorization": { + "matches": "Bearer .+" + } + }, + "pathParameters": { + "docId": { + "equalTo": "docId" + }, + "layerName": { + "equalTo": "layerName" + } + } + }, + "response": { + "status": 200, + "body": "{\n \"key\": \"value\"\n}", + "headers": { + "Content-Type": "application/json" + } + }, + "uuid": "53b73685-826d-4bfc-bdfe-73f37c3c7451", + "persistent": true, + "priority": 3, + "metadata": { + "mocklab": { + "created": { + "at": "2020-01-01T00:00:00.000Z", + "via": "SYSTEM" + } + } + } + }, { "id": "78516831-9031-4a14-a631-55eeb9bdba9a", "name": "Flatten annotations and form fields into page content. - default", @@ -1597,6 +1636,84 @@ } } }, + { + "id": "63bf8e89-7f23-4209-9e8d-03036a433643", + "name": "Copy every page of an uploaded PDF into the document at an index. - default", + "request": { + "urlPathTemplate": "/v1/docs/{docId}/layers/{layerName}/pages/insert", + "method": "POST", + "headers": { + "Authorization": { + "matches": "Bearer .+" + } + }, + "pathParameters": { + "docId": { + "equalTo": "docId" + }, + "layerName": { + "equalTo": "layerName" + } + } + }, + "response": { + "status": 200, + "body": "{\n \"meta\": {\n \"affectedPages\": [\n {\n \"pageObjectNumber\": 1,\n \"revision\": {\n \"docSessionId\": \"docSessionId\",\n \"pageObjectNumber\": 1,\n \"generation\": 1\n },\n \"weakAnnotationState\": {\n \"kind\": \"unknown\"\n }\n }\n ],\n \"cacheDelta\": {\n \"previousDocVersion\": 1,\n \"docVersion\": 1,\n \"pages\": [\n {\n \"pageObjectNumber\": 1,\n \"cache\": {\n \"contentVersion\": 1,\n \"annotationVersion\": 1\n }\n }\n ]\n }\n }\n}", + "headers": { + "Content-Type": "application/json" + } + }, + "uuid": "63bf8e89-7f23-4209-9e8d-03036a433643", + "persistent": true, + "priority": 3, + "metadata": { + "mocklab": { + "created": { + "at": "2020-01-01T00:00:00.000Z", + "via": "SYSTEM" + } + } + } + }, + { + "id": "6c708cf7-ea22-437b-9bd5-100587d6a2fd", + "name": "Create blank pages of an explicit size at an index. - default", + "request": { + "urlPathTemplate": "/v1/docs/{docId}/layers/{layerName}/pages/insert-blank", + "method": "POST", + "headers": { + "Authorization": { + "matches": "Bearer .+" + } + }, + "pathParameters": { + "docId": { + "equalTo": "docId" + }, + "layerName": { + "equalTo": "layerName" + } + } + }, + "response": { + "status": 200, + "body": "{\n \"meta\": {\n \"affectedPages\": [\n {\n \"pageObjectNumber\": 1,\n \"revision\": {\n \"docSessionId\": \"docSessionId\",\n \"pageObjectNumber\": 1,\n \"generation\": 1\n },\n \"weakAnnotationState\": {\n \"kind\": \"unknown\"\n }\n }\n ],\n \"cacheDelta\": {\n \"previousDocVersion\": 1,\n \"docVersion\": 1,\n \"pages\": [\n {\n \"pageObjectNumber\": 1,\n \"cache\": {\n \"contentVersion\": 1,\n \"annotationVersion\": 1\n }\n }\n ]\n }\n }\n}", + "headers": { + "Content-Type": "application/json" + } + }, + "uuid": "6c708cf7-ea22-437b-9bd5-100587d6a2fd", + "persistent": true, + "priority": 3, + "metadata": { + "mocklab": { + "created": { + "at": "2020-01-01T00:00:00.000Z", + "via": "SYSTEM" + } + } + } + }, { "id": "27361925-5428-4b11-bebc-98ad9cb34fc7", "name": "Reorder pages. - default", @@ -1716,6 +1833,6 @@ } ], "meta": { - "total": 45 + "total": 48 } } \ No newline at end of file