/* * Generated file models/datapolicies/v4/config/config_model.go. * * Product version: 4.3.2 * * Part of the Nutanix Data Policies APIs * * (c) 2026 Nutanix Inc. All rights reserved * */ /* Manage disaster recovery and storage policies. */ package config import ( "bytes" "encoding/json" "errors" "fmt" import4 "github.com/nutanix/ntnx-api-golang-clients/datapolicies-go-client/v4/models/common/v1/config" import1 "github.com/nutanix/ntnx-api-golang-clients/datapolicies-go-client/v4/models/common/v1/response" import3 "github.com/nutanix/ntnx-api-golang-clients/datapolicies-go-client/v4/models/datapolicies/v4/error" import7 "github.com/nutanix/ntnx-api-golang-clients/datapolicies-go-client/v4/models/dataprotection/v4/common" import5 "github.com/nutanix/ntnx-api-golang-clients/datapolicies-go-client/v4/models/networking/v4/config" import2 "github.com/nutanix/ntnx-api-golang-clients/datapolicies-go-client/v4/models/prism/v4/config" import6 "github.com/nutanix/ntnx-api-golang-clients/datapolicies-go-client/v4/models/volumes/v4/config" ) /* Maintains a rolling window of recovery points for every schedule, starting with the hourly schedule and ending with the schedule created for the specified retention period. For example, if the retention period is 4 weeks, at any given time, you will have 24 of the latest hourly recovery points, 7 of the latest daily recovery points, and 4 of the latest weekly recovery points. */ type AutoRollupRetention struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` Local *AutoRollupRetentionDetails `json:"local"` Remote *AutoRollupRetentionDetails `json:"remote,omitempty"` } func (p *AutoRollupRetention) MarshalJSON() ([]byte, error) { type AutoRollupRetentionProxy AutoRollupRetention // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *AutoRollupRetentionProxy Local *AutoRollupRetentionDetails `json:"local,omitempty"` }{ AutoRollupRetentionProxy: (*AutoRollupRetentionProxy)(p), Local: p.Local, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *AutoRollupRetention) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias AutoRollupRetention known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewAutoRollupRetention() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.Local != nil { p.Local = known.Local } if known.Remote != nil { p.Remote = known.Remote } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "local") delete(allFields, "remote") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewAutoRollupRetention() *AutoRollupRetention { p := new(AutoRollupRetention) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.AutoRollupRetention" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Specifies the auto rollup retention details. */ type AutoRollupRetentionDetails struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* Multiplier to 'snapshotIntervalType'. For example, if 'snapshotIntervalType' is 'YEARLY' and 'multiple' is 5, then 5 years worth of rollup snapshots will be retained. */ Frequency *int `json:"frequency"` SnapshotIntervalType *SnapshotIntervalType `json:"snapshotIntervalType"` } func (p *AutoRollupRetentionDetails) MarshalJSON() ([]byte, error) { type AutoRollupRetentionDetailsProxy AutoRollupRetentionDetails // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *AutoRollupRetentionDetailsProxy Frequency *int `json:"frequency,omitempty"` SnapshotIntervalType *SnapshotIntervalType `json:"snapshotIntervalType,omitempty"` }{ AutoRollupRetentionDetailsProxy: (*AutoRollupRetentionDetailsProxy)(p), Frequency: p.Frequency, SnapshotIntervalType: p.SnapshotIntervalType, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *AutoRollupRetentionDetails) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias AutoRollupRetentionDetails known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewAutoRollupRetentionDetails() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.Frequency != nil { p.Frequency = known.Frequency } if known.SnapshotIntervalType != nil { p.SnapshotIntervalType = known.SnapshotIntervalType } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "frequency") delete(allFields, "snapshotIntervalType") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewAutoRollupRetentionDetails() *AutoRollupRetentionDetails { p := new(AutoRollupRetentionDetails) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.AutoRollupRetentionDetails" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Compression parameters for the entities governed by the Storage Policy. */ type CompressionSpec struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` CompressionState *CompressionState `json:"compressionState"` } func (p *CompressionSpec) MarshalJSON() ([]byte, error) { type CompressionSpecProxy CompressionSpec // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *CompressionSpecProxy CompressionState *CompressionState `json:"compressionState,omitempty"` }{ CompressionSpecProxy: (*CompressionSpecProxy)(p), CompressionState: p.CompressionState, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *CompressionSpec) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias CompressionSpec known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewCompressionSpec() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.CompressionState != nil { p.CompressionState = known.CompressionState } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "compressionState") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewCompressionSpec() *CompressionSpec { p := new(CompressionSpec) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.CompressionSpec" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Enable or disable Compression for entities governed by the policy. If the user has no explicit Compression preference, the system chooses an appropriate value. */ type CompressionState int const ( COMPRESSIONSTATE_UNKNOWN CompressionState = 0 COMPRESSIONSTATE_REDACTED CompressionState = 1 COMPRESSIONSTATE_INLINE CompressionState = 2 COMPRESSIONSTATE_POSTPROCESS CompressionState = 3 COMPRESSIONSTATE_DISABLED CompressionState = 4 COMPRESSIONSTATE_SYSTEM_DERIVED CompressionState = 5 ) // Returns the name of the enum given an ordinal number // // Deprecated: Please use GetName instead of name func (e *CompressionState) name(index int) string { names := [...]string{ "$UNKNOWN", "$REDACTED", "INLINE", "POSTPROCESS", "DISABLED", "SYSTEM_DERIVED", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the name of the enum func (e CompressionState) GetName() string { index := int(e) names := [...]string{ "$UNKNOWN", "$REDACTED", "INLINE", "POSTPROCESS", "DISABLED", "SYSTEM_DERIVED", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the enum type given a string value func (e *CompressionState) index(name string) CompressionState { names := [...]string{ "$UNKNOWN", "$REDACTED", "INLINE", "POSTPROCESS", "DISABLED", "SYSTEM_DERIVED", } for idx := range names { if names[idx] == name { return CompressionState(idx) } } return COMPRESSIONSTATE_UNKNOWN } func (e *CompressionState) UnmarshalJSON(b []byte) error { var enumStr string if err := json.Unmarshal(b, &enumStr); err != nil { return errors.New(fmt.Sprintf("Unable to unmarshal for CompressionState:%s", err)) } *e = e.index(enumStr) return nil } func (e *CompressionState) MarshalJSON() ([]byte, error) { b := bytes.NewBufferString(`"`) b.WriteString(e.name(int(*e))) b.WriteString(`"`) return b.Bytes(), nil } func (e CompressionState) Ref() *CompressionState { return &e } /* There are many scenarios in which it is essential to capture an application's state as an aggregate of the internal states of a group of related entities at a specific moment in time. The consistency rule is a collection of all the entities whose snapshot represents the application state at that point in time. */ type ConsistencyRule struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* Specifies the list of external identifiers of categories that must form the consistency rule. This consistently protects any VM or volume group associated with this category. The number of entities attached to these categories should not exceed 32, and should reside in the same cluster. */ CategoryIds []string `json:"categoryIds"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` /* Name of the consistency rule. */ Name *string `json:"name"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` } func (p *ConsistencyRule) MarshalJSON() ([]byte, error) { type ConsistencyRuleProxy ConsistencyRule // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *ConsistencyRuleProxy CategoryIds []string `json:"categoryIds,omitempty"` Name *string `json:"name,omitempty"` }{ ConsistencyRuleProxy: (*ConsistencyRuleProxy)(p), CategoryIds: p.CategoryIds, Name: p.Name, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *ConsistencyRule) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias ConsistencyRule known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewConsistencyRule() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.CategoryIds != nil { p.CategoryIds = known.CategoryIds } if known.ExtId != nil { p.ExtId = known.ExtId } if known.Links != nil { p.Links = known.Links } if known.Name != nil { p.Name = known.Name } if known.TenantId != nil { p.TenantId = known.TenantId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "categoryIds") delete(allFields, "extId") delete(allFields, "links") delete(allFields, "name") delete(allFields, "tenantId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewConsistencyRule() *ConsistencyRule { p := new(ConsistencyRule) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.ConsistencyRule" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } type ConsistencyRuleProjection struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* Specifies the list of external identifiers of categories that must form the consistency rule. This consistently protects any VM or volume group associated with this category. The number of entities attached to these categories should not exceed 32, and should reside in the same cluster. */ CategoryIds []string `json:"categoryIds"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` /* Name of the consistency rule. */ Name *string `json:"name"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` } func (p *ConsistencyRuleProjection) MarshalJSON() ([]byte, error) { type ConsistencyRuleProjectionProxy ConsistencyRuleProjection // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *ConsistencyRuleProjectionProxy CategoryIds []string `json:"categoryIds,omitempty"` Name *string `json:"name,omitempty"` }{ ConsistencyRuleProjectionProxy: (*ConsistencyRuleProjectionProxy)(p), CategoryIds: p.CategoryIds, Name: p.Name, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *ConsistencyRuleProjection) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias ConsistencyRuleProjection known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewConsistencyRuleProjection() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.CategoryIds != nil { p.CategoryIds = known.CategoryIds } if known.ExtId != nil { p.ExtId = known.ExtId } if known.Links != nil { p.Links = known.Links } if known.Name != nil { p.Name = known.Name } if known.TenantId != nil { p.TenantId = known.TenantId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "categoryIds") delete(allFields, "extId") delete(allFields, "links") delete(allFields, "name") delete(allFields, "tenantId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewConsistencyRuleProjection() *ConsistencyRuleProjection { p := new(ConsistencyRuleProjection) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.ConsistencyRuleProjection" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* REST response for all response codes in API path /datapolicies/v4.3/config/protection-policies/{protectionPolicyExtId}/consistency-rules Post operation */ type CreateConsistencyRuleApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfCreateConsistencyRuleApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *CreateConsistencyRuleApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias CreateConsistencyRuleApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *CreateConsistencyRuleApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias CreateConsistencyRuleApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewCreateConsistencyRuleApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewCreateConsistencyRuleApiResponse() *CreateConsistencyRuleApiResponse { p := new(CreateConsistencyRuleApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.CreateConsistencyRuleApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *CreateConsistencyRuleApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *CreateConsistencyRuleApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfCreateConsistencyRuleApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/data-services-ip-mappings Post operation */ type CreateDataServicesIpMappingApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfCreateDataServicesIpMappingApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *CreateDataServicesIpMappingApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias CreateDataServicesIpMappingApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *CreateDataServicesIpMappingApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias CreateDataServicesIpMappingApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewCreateDataServicesIpMappingApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewCreateDataServicesIpMappingApiResponse() *CreateDataServicesIpMappingApiResponse { p := new(CreateDataServicesIpMappingApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.CreateDataServicesIpMappingApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *CreateDataServicesIpMappingApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *CreateDataServicesIpMappingApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfCreateDataServicesIpMappingApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/network-mappings Post operation */ type CreateNetworkMappingApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfCreateNetworkMappingApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *CreateNetworkMappingApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias CreateNetworkMappingApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *CreateNetworkMappingApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias CreateNetworkMappingApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewCreateNetworkMappingApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewCreateNetworkMappingApiResponse() *CreateNetworkMappingApiResponse { p := new(CreateNetworkMappingApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.CreateNetworkMappingApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *CreateNetworkMappingApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *CreateNetworkMappingApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfCreateNetworkMappingApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/protection-policies Post operation */ type CreateProtectionPolicyApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfCreateProtectionPolicyApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *CreateProtectionPolicyApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias CreateProtectionPolicyApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *CreateProtectionPolicyApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias CreateProtectionPolicyApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewCreateProtectionPolicyApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewCreateProtectionPolicyApiResponse() *CreateProtectionPolicyApiResponse { p := new(CreateProtectionPolicyApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.CreateProtectionPolicyApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *CreateProtectionPolicyApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *CreateProtectionPolicyApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfCreateProtectionPolicyApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans Post operation */ type CreateRecoveryPlanApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfCreateRecoveryPlanApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *CreateRecoveryPlanApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias CreateRecoveryPlanApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *CreateRecoveryPlanApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias CreateRecoveryPlanApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewCreateRecoveryPlanApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewCreateRecoveryPlanApiResponse() *CreateRecoveryPlanApiResponse { p := new(CreateRecoveryPlanApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.CreateRecoveryPlanApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *CreateRecoveryPlanApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *CreateRecoveryPlanApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfCreateRecoveryPlanApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/recovery-settings Post operation */ type CreateRecoverySettingApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfCreateRecoverySettingApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *CreateRecoverySettingApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias CreateRecoverySettingApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *CreateRecoverySettingApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias CreateRecoverySettingApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewCreateRecoverySettingApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewCreateRecoverySettingApiResponse() *CreateRecoverySettingApiResponse { p := new(CreateRecoverySettingApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.CreateRecoverySettingApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *CreateRecoverySettingApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *CreateRecoverySettingApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfCreateRecoverySettingApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/stages Post operation */ type CreateRecoveryStageApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfCreateRecoveryStageApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *CreateRecoveryStageApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias CreateRecoveryStageApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *CreateRecoveryStageApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias CreateRecoveryStageApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewCreateRecoveryStageApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewCreateRecoveryStageApiResponse() *CreateRecoveryStageApiResponse { p := new(CreateRecoveryStageApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.CreateRecoveryStageApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *CreateRecoveryStageApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *CreateRecoveryStageApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfCreateRecoveryStageApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/storage-policies Post operation */ type CreateStoragePolicyApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfCreateStoragePolicyApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *CreateStoragePolicyApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias CreateStoragePolicyApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *CreateStoragePolicyApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias CreateStoragePolicyApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewCreateStoragePolicyApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewCreateStoragePolicyApiResponse() *CreateStoragePolicyApiResponse { p := new(CreateStoragePolicyApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.CreateStoragePolicyApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *CreateStoragePolicyApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *CreateStoragePolicyApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfCreateStoragePolicyApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* Mapping between data services IP of primary and recovery Prism Elements. This mapping will be used to establish the iSCSI connection between the recovered VMs with the recovered Volume groups when network segmentation has been enabled.

VMs using the `primaryDataServicesIp` as the iSCSI target IP on primary will be updated with `recoveryDataServicesIp` or `recoveryTestDataServicesIp` on the recovery depending upon whether the failover action is `PLANNED_FAILOVER`, `UNPLANNED_FAILOVER` or `TEST_FAILOVER`.

During failback the VMs using the `recoveryDataServicesIp` as the iSCSI target IP on recovery will be updated with `primaryDataServicesIp` or `primaryTestDataServicesIp` depending upon whether the failover action is `PLANNED_FAILOVER`, `UNPLANNED_FAILOVER` or `TEST_FAILOVER`. */ type DataServicesIpMapping struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` PrimaryCluster *EntityReference `json:"primaryCluster"` PrimaryDataServicesIp *import4.IPAddress `json:"primaryDataServicesIp"` PrimaryTestDataServicesIp *import4.IPAddress `json:"primaryTestDataServicesIp,omitempty"` RecoveryCluster *EntityReference `json:"recoveryCluster"` RecoveryDataServicesIp *import4.IPAddress `json:"recoveryDataServicesIp"` RecoveryTestDataServicesIp *import4.IPAddress `json:"recoveryTestDataServicesIp,omitempty"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` } func (p *DataServicesIpMapping) MarshalJSON() ([]byte, error) { type DataServicesIpMappingProxy DataServicesIpMapping // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *DataServicesIpMappingProxy PrimaryCluster *EntityReference `json:"primaryCluster,omitempty"` PrimaryDataServicesIp *import4.IPAddress `json:"primaryDataServicesIp,omitempty"` RecoveryCluster *EntityReference `json:"recoveryCluster,omitempty"` RecoveryDataServicesIp *import4.IPAddress `json:"recoveryDataServicesIp,omitempty"` }{ DataServicesIpMappingProxy: (*DataServicesIpMappingProxy)(p), PrimaryCluster: p.PrimaryCluster, PrimaryDataServicesIp: p.PrimaryDataServicesIp, RecoveryCluster: p.RecoveryCluster, RecoveryDataServicesIp: p.RecoveryDataServicesIp, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *DataServicesIpMapping) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias DataServicesIpMapping known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewDataServicesIpMapping() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.ExtId != nil { p.ExtId = known.ExtId } if known.Links != nil { p.Links = known.Links } if known.PrimaryCluster != nil { p.PrimaryCluster = known.PrimaryCluster } if known.PrimaryDataServicesIp != nil { p.PrimaryDataServicesIp = known.PrimaryDataServicesIp } if known.PrimaryTestDataServicesIp != nil { p.PrimaryTestDataServicesIp = known.PrimaryTestDataServicesIp } if known.RecoveryCluster != nil { p.RecoveryCluster = known.RecoveryCluster } if known.RecoveryDataServicesIp != nil { p.RecoveryDataServicesIp = known.RecoveryDataServicesIp } if known.RecoveryTestDataServicesIp != nil { p.RecoveryTestDataServicesIp = known.RecoveryTestDataServicesIp } if known.TenantId != nil { p.TenantId = known.TenantId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "extId") delete(allFields, "links") delete(allFields, "primaryCluster") delete(allFields, "primaryDataServicesIp") delete(allFields, "primaryTestDataServicesIp") delete(allFields, "recoveryCluster") delete(allFields, "recoveryDataServicesIp") delete(allFields, "recoveryTestDataServicesIp") delete(allFields, "tenantId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewDataServicesIpMapping() *DataServicesIpMapping { p := new(DataServicesIpMapping) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.DataServicesIpMapping" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } type DataServicesIpMappingProjection struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` PrimaryCluster *EntityReference `json:"primaryCluster"` PrimaryDataServicesIp *import4.IPAddress `json:"primaryDataServicesIp"` PrimaryTestDataServicesIp *import4.IPAddress `json:"primaryTestDataServicesIp,omitempty"` RecoveryCluster *EntityReference `json:"recoveryCluster"` RecoveryDataServicesIp *import4.IPAddress `json:"recoveryDataServicesIp"` RecoveryTestDataServicesIp *import4.IPAddress `json:"recoveryTestDataServicesIp,omitempty"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` } func (p *DataServicesIpMappingProjection) MarshalJSON() ([]byte, error) { type DataServicesIpMappingProjectionProxy DataServicesIpMappingProjection // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *DataServicesIpMappingProjectionProxy PrimaryCluster *EntityReference `json:"primaryCluster,omitempty"` PrimaryDataServicesIp *import4.IPAddress `json:"primaryDataServicesIp,omitempty"` RecoveryCluster *EntityReference `json:"recoveryCluster,omitempty"` RecoveryDataServicesIp *import4.IPAddress `json:"recoveryDataServicesIp,omitempty"` }{ DataServicesIpMappingProjectionProxy: (*DataServicesIpMappingProjectionProxy)(p), PrimaryCluster: p.PrimaryCluster, PrimaryDataServicesIp: p.PrimaryDataServicesIp, RecoveryCluster: p.RecoveryCluster, RecoveryDataServicesIp: p.RecoveryDataServicesIp, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *DataServicesIpMappingProjection) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias DataServicesIpMappingProjection known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewDataServicesIpMappingProjection() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.ExtId != nil { p.ExtId = known.ExtId } if known.Links != nil { p.Links = known.Links } if known.PrimaryCluster != nil { p.PrimaryCluster = known.PrimaryCluster } if known.PrimaryDataServicesIp != nil { p.PrimaryDataServicesIp = known.PrimaryDataServicesIp } if known.PrimaryTestDataServicesIp != nil { p.PrimaryTestDataServicesIp = known.PrimaryTestDataServicesIp } if known.RecoveryCluster != nil { p.RecoveryCluster = known.RecoveryCluster } if known.RecoveryDataServicesIp != nil { p.RecoveryDataServicesIp = known.RecoveryDataServicesIp } if known.RecoveryTestDataServicesIp != nil { p.RecoveryTestDataServicesIp = known.RecoveryTestDataServicesIp } if known.TenantId != nil { p.TenantId = known.TenantId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "extId") delete(allFields, "links") delete(allFields, "primaryCluster") delete(allFields, "primaryDataServicesIp") delete(allFields, "primaryTestDataServicesIp") delete(allFields, "recoveryCluster") delete(allFields, "recoveryDataServicesIp") delete(allFields, "recoveryTestDataServicesIp") delete(allFields, "tenantId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewDataServicesIpMappingProjection() *DataServicesIpMappingProjection { p := new(DataServicesIpMappingProjection) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.DataServicesIpMappingProjection" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Defines the starting day of the week for taking and replicating the first snapshot of any new entity added in the policy. If this is not specified, the snapshot and replication will follow the daily protection start time. */ type DayOfWeek int const ( DAYOFWEEK_UNKNOWN DayOfWeek = 0 DAYOFWEEK_REDACTED DayOfWeek = 1 DAYOFWEEK_SUNDAY DayOfWeek = 2 DAYOFWEEK_MONDAY DayOfWeek = 3 DAYOFWEEK_TUESDAY DayOfWeek = 4 DAYOFWEEK_WEDNESDAY DayOfWeek = 5 DAYOFWEEK_THURSDAY DayOfWeek = 6 DAYOFWEEK_FRIDAY DayOfWeek = 7 DAYOFWEEK_SATURDAY DayOfWeek = 8 ) // Returns the name of the enum given an ordinal number // // Deprecated: Please use GetName instead of name func (e *DayOfWeek) name(index int) string { names := [...]string{ "$UNKNOWN", "$REDACTED", "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the name of the enum func (e DayOfWeek) GetName() string { index := int(e) names := [...]string{ "$UNKNOWN", "$REDACTED", "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the enum type given a string value func (e *DayOfWeek) index(name string) DayOfWeek { names := [...]string{ "$UNKNOWN", "$REDACTED", "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", } for idx := range names { if names[idx] == name { return DayOfWeek(idx) } } return DAYOFWEEK_UNKNOWN } func (e *DayOfWeek) UnmarshalJSON(b []byte) error { var enumStr string if err := json.Unmarshal(b, &enumStr); err != nil { return errors.New(fmt.Sprintf("Unable to unmarshal for DayOfWeek:%s", err)) } *e = e.index(enumStr) return nil } func (e *DayOfWeek) MarshalJSON() ([]byte, error) { b := bytes.NewBufferString(`"`) b.WriteString(e.name(int(*e))) b.WriteString(`"`) return b.Bytes(), nil } func (e DayOfWeek) Ref() *DayOfWeek { return &e } /* The settings required for stage action DELAY. */ type DelayAction struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* The number of seconds for which the Recovery plan needs to be delayed after the stage recovery is completed. */ DelaySecs *int `json:"delaySecs"` } func (p *DelayAction) MarshalJSON() ([]byte, error) { type DelayActionProxy DelayAction // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *DelayActionProxy DelaySecs *int `json:"delaySecs,omitempty"` }{ DelayActionProxy: (*DelayActionProxy)(p), DelaySecs: p.DelaySecs, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *DelayAction) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias DelayAction known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewDelayAction() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DelaySecs != nil { p.DelaySecs = known.DelaySecs } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "delaySecs") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewDelayAction() *DelayAction { p := new(DelayAction) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.DelayAction" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* REST response for all response codes in API path /datapolicies/v4.3/config/protection-policies/{protectionPolicyExtId}/consistency-rules/{extId} Delete operation */ type DeleteConsistencyRuleApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfDeleteConsistencyRuleApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *DeleteConsistencyRuleApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias DeleteConsistencyRuleApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *DeleteConsistencyRuleApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias DeleteConsistencyRuleApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewDeleteConsistencyRuleApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewDeleteConsistencyRuleApiResponse() *DeleteConsistencyRuleApiResponse { p := new(DeleteConsistencyRuleApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.DeleteConsistencyRuleApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *DeleteConsistencyRuleApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *DeleteConsistencyRuleApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfDeleteConsistencyRuleApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/data-services-ip-mappings/{extId} Delete operation */ type DeleteDataServicesIpMappingApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfDeleteDataServicesIpMappingApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *DeleteDataServicesIpMappingApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias DeleteDataServicesIpMappingApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *DeleteDataServicesIpMappingApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias DeleteDataServicesIpMappingApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewDeleteDataServicesIpMappingApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewDeleteDataServicesIpMappingApiResponse() *DeleteDataServicesIpMappingApiResponse { p := new(DeleteDataServicesIpMappingApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.DeleteDataServicesIpMappingApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *DeleteDataServicesIpMappingApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *DeleteDataServicesIpMappingApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfDeleteDataServicesIpMappingApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/network-mappings/{extId} Delete operation */ type DeleteNetworkMappingApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfDeleteNetworkMappingApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *DeleteNetworkMappingApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias DeleteNetworkMappingApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *DeleteNetworkMappingApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias DeleteNetworkMappingApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewDeleteNetworkMappingApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewDeleteNetworkMappingApiResponse() *DeleteNetworkMappingApiResponse { p := new(DeleteNetworkMappingApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.DeleteNetworkMappingApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *DeleteNetworkMappingApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *DeleteNetworkMappingApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfDeleteNetworkMappingApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/protection-policies/{extId} Delete operation */ type DeleteProtectionPolicyApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfDeleteProtectionPolicyApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *DeleteProtectionPolicyApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias DeleteProtectionPolicyApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *DeleteProtectionPolicyApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias DeleteProtectionPolicyApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewDeleteProtectionPolicyApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewDeleteProtectionPolicyApiResponse() *DeleteProtectionPolicyApiResponse { p := new(DeleteProtectionPolicyApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.DeleteProtectionPolicyApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *DeleteProtectionPolicyApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *DeleteProtectionPolicyApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfDeleteProtectionPolicyApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{extId} Delete operation */ type DeleteRecoveryPlanApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfDeleteRecoveryPlanApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *DeleteRecoveryPlanApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias DeleteRecoveryPlanApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *DeleteRecoveryPlanApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias DeleteRecoveryPlanApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewDeleteRecoveryPlanApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewDeleteRecoveryPlanApiResponse() *DeleteRecoveryPlanApiResponse { p := new(DeleteRecoveryPlanApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.DeleteRecoveryPlanApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *DeleteRecoveryPlanApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *DeleteRecoveryPlanApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfDeleteRecoveryPlanApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/recovery-settings/{extId} Delete operation */ type DeleteRecoverySettingApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfDeleteRecoverySettingApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *DeleteRecoverySettingApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias DeleteRecoverySettingApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *DeleteRecoverySettingApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias DeleteRecoverySettingApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewDeleteRecoverySettingApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewDeleteRecoverySettingApiResponse() *DeleteRecoverySettingApiResponse { p := new(DeleteRecoverySettingApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.DeleteRecoverySettingApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *DeleteRecoverySettingApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *DeleteRecoverySettingApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfDeleteRecoverySettingApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/stages/{extId} Delete operation */ type DeleteRecoveryStageApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfDeleteRecoveryStageApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *DeleteRecoveryStageApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias DeleteRecoveryStageApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *DeleteRecoveryStageApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias DeleteRecoveryStageApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewDeleteRecoveryStageApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewDeleteRecoveryStageApiResponse() *DeleteRecoveryStageApiResponse { p := new(DeleteRecoveryStageApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.DeleteRecoveryStageApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *DeleteRecoveryStageApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *DeleteRecoveryStageApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfDeleteRecoveryStageApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/storage-policies/{extId} Delete operation */ type DeleteStoragePolicyApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfDeleteStoragePolicyApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *DeleteStoragePolicyApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias DeleteStoragePolicyApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *DeleteStoragePolicyApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias DeleteStoragePolicyApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewDeleteStoragePolicyApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewDeleteStoragePolicyApiResponse() *DeleteStoragePolicyApiResponse { p := new(DeleteStoragePolicyApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.DeleteStoragePolicyApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *DeleteStoragePolicyApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *DeleteStoragePolicyApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfDeleteStoragePolicyApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* Details of disaster recovery location */ type DisasterRecoveryLocation struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* List of Prism Element cluster external references. Required in the scenario when both primary and secondary Prism Elements are managed by the same Domain manager. */ Clusters []EntityReference `json:"clusters,omitempty"` /* External identifier of the Domain manager. */ DomainManagerExtId *string `json:"domainManagerExtId"` } func (p *DisasterRecoveryLocation) MarshalJSON() ([]byte, error) { type DisasterRecoveryLocationProxy DisasterRecoveryLocation // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *DisasterRecoveryLocationProxy DomainManagerExtId *string `json:"domainManagerExtId,omitempty"` }{ DisasterRecoveryLocationProxy: (*DisasterRecoveryLocationProxy)(p), DomainManagerExtId: p.DomainManagerExtId, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *DisasterRecoveryLocation) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias DisasterRecoveryLocation known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewDisasterRecoveryLocation() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.Clusters != nil { p.Clusters = known.Clusters } if known.DomainManagerExtId != nil { p.DomainManagerExtId = known.DomainManagerExtId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "clusters") delete(allFields, "domainManagerExtId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewDisasterRecoveryLocation() *DisasterRecoveryLocation { p := new(DisasterRecoveryLocation) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.DisasterRecoveryLocation" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Encryption parameters for the entities governed by the Storage Policy. */ type EncryptionSpec struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` EncryptionState *EncryptionState `json:"encryptionState"` } func (p *EncryptionSpec) MarshalJSON() ([]byte, error) { type EncryptionSpecProxy EncryptionSpec // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *EncryptionSpecProxy EncryptionState *EncryptionState `json:"encryptionState,omitempty"` }{ EncryptionSpecProxy: (*EncryptionSpecProxy)(p), EncryptionState: p.EncryptionState, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *EncryptionSpec) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias EncryptionSpec known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewEncryptionSpec() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.EncryptionState != nil { p.EncryptionState = known.EncryptionState } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "encryptionState") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewEncryptionSpec() *EncryptionSpec { p := new(EncryptionSpec) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.EncryptionSpec" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Enable Encryption for entities. Once enabled, it cannot be disabled. If the user does not have an explicit preference to enable Encryption, the system decides on an appropriate value. */ type EncryptionState int const ( ENCRYPTIONSTATE_UNKNOWN EncryptionState = 0 ENCRYPTIONSTATE_REDACTED EncryptionState = 1 ENCRYPTIONSTATE_ENABLED EncryptionState = 2 ENCRYPTIONSTATE_SYSTEM_DERIVED EncryptionState = 3 ) // Returns the name of the enum given an ordinal number // // Deprecated: Please use GetName instead of name func (e *EncryptionState) name(index int) string { names := [...]string{ "$UNKNOWN", "$REDACTED", "ENABLED", "SYSTEM_DERIVED", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the name of the enum func (e EncryptionState) GetName() string { index := int(e) names := [...]string{ "$UNKNOWN", "$REDACTED", "ENABLED", "SYSTEM_DERIVED", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the enum type given a string value func (e *EncryptionState) index(name string) EncryptionState { names := [...]string{ "$UNKNOWN", "$REDACTED", "ENABLED", "SYSTEM_DERIVED", } for idx := range names { if names[idx] == name { return EncryptionState(idx) } } return ENCRYPTIONSTATE_UNKNOWN } func (e *EncryptionState) UnmarshalJSON(b []byte) error { var enumStr string if err := json.Unmarshal(b, &enumStr); err != nil { return errors.New(fmt.Sprintf("Unable to unmarshal for EncryptionState:%s", err)) } *e = e.index(enumStr) return nil } func (e *EncryptionState) MarshalJSON() ([]byte, error) { b := bytes.NewBufferString(`"`) b.WriteString(e.name(int(*e))) b.WriteString(`"`) return b.Bytes(), nil } func (e EncryptionState) Ref() *EncryptionState { return &e } /* External reference of an entity. */ type EntityReference struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* External identifier of the entity. */ ExtId *string `json:"extId"` } func (p *EntityReference) MarshalJSON() ([]byte, error) { type EntityReferenceProxy EntityReference // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *EntityReferenceProxy ExtId *string `json:"extId,omitempty"` }{ EntityReferenceProxy: (*EntityReferenceProxy)(p), ExtId: p.ExtId, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *EntityReference) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias EntityReference known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewEntityReference() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.ExtId != nil { p.ExtId = known.ExtId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "extId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewEntityReference() *EntityReference { p := new(EntityReference) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.EntityReference" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* The entity sync policy synchronizes various policies such as Network Security Policy and Storage Policy across domain managers to ensure consistent infrastructure configurations */ type EntitySyncPolicy struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* External identifier of the entity. */ EntityExtId *string `json:"entityExtId,omitempty"` /* Name of the entity. */ EntityName *string `json:"entityName,omitempty"` EntityType *SyncedEntityType `json:"entityType,omitempty"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` /* External identifier of the owner of the entity sync policy. */ OwnerExtId *string `json:"ownerExtId,omitempty"` /* External identifier of the remote domain manager. */ RemoteDomainManagerExtId *string `json:"remoteDomainManagerExtId,omitempty"` Status *EntitySyncStatus `json:"status,omitempty"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` } func (p *EntitySyncPolicy) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias EntitySyncPolicy // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *EntitySyncPolicy) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias EntitySyncPolicy known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewEntitySyncPolicy() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.EntityExtId != nil { p.EntityExtId = known.EntityExtId } if known.EntityName != nil { p.EntityName = known.EntityName } if known.EntityType != nil { p.EntityType = known.EntityType } if known.ExtId != nil { p.ExtId = known.ExtId } if known.Links != nil { p.Links = known.Links } if known.OwnerExtId != nil { p.OwnerExtId = known.OwnerExtId } if known.RemoteDomainManagerExtId != nil { p.RemoteDomainManagerExtId = known.RemoteDomainManagerExtId } if known.Status != nil { p.Status = known.Status } if known.TenantId != nil { p.TenantId = known.TenantId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "entityExtId") delete(allFields, "entityName") delete(allFields, "entityType") delete(allFields, "extId") delete(allFields, "links") delete(allFields, "ownerExtId") delete(allFields, "remoteDomainManagerExtId") delete(allFields, "status") delete(allFields, "tenantId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewEntitySyncPolicy() *EntitySyncPolicy { p := new(EntitySyncPolicy) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.EntitySyncPolicy" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } type EntitySyncPolicyAggregate struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` Label *string `json:"label,omitempty"` ResultItemDiscriminator_ *string `json:"$resultItemDiscriminator,omitempty"` Result *OneOfEntitySyncPolicyAggregateResult `json:"result,omitempty"` } func (p *EntitySyncPolicyAggregate) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias EntitySyncPolicyAggregate // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *EntitySyncPolicyAggregate) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias EntitySyncPolicyAggregate known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewEntitySyncPolicyAggregate() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.Label != nil { p.Label = known.Label } if known.ResultItemDiscriminator_ != nil { p.ResultItemDiscriminator_ = known.ResultItemDiscriminator_ } if known.Result != nil { p.Result = known.Result } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "label") delete(allFields, "$resultItemDiscriminator") delete(allFields, "result") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewEntitySyncPolicyAggregate() *EntitySyncPolicyAggregate { p := new(EntitySyncPolicyAggregate) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.EntitySyncPolicyAggregate" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *EntitySyncPolicyAggregate) GetResult() interface{} { if nil == p.Result { return nil } return p.Result.GetValue() } func (p *EntitySyncPolicyAggregate) SetResult(v interface{}) error { if nil == p.Result { p.Result = NewOneOfEntitySyncPolicyAggregateResult() } e := p.Result.SetValue(v) if nil == e { if nil == p.ResultItemDiscriminator_ { p.ResultItemDiscriminator_ = new(string) } *p.ResultItemDiscriminator_ = *p.Result.Discriminator } return e } type EntitySyncPolicyGroup struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` Aggregates []EntitySyncPolicyAggregate `json:"aggregates,omitempty"` DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfEntitySyncPolicyGroupData `json:"data,omitempty"` GroupItemDiscriminator_ *string `json:"$groupItemDiscriminator,omitempty"` Group *OneOfEntitySyncPolicyGroupGroup `json:"group,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *EntitySyncPolicyGroup) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias EntitySyncPolicyGroup // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *EntitySyncPolicyGroup) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias EntitySyncPolicyGroup known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewEntitySyncPolicyGroup() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.Aggregates != nil { p.Aggregates = known.Aggregates } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.GroupItemDiscriminator_ != nil { p.GroupItemDiscriminator_ = known.GroupItemDiscriminator_ } if known.Group != nil { p.Group = known.Group } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "aggregates") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "$groupItemDiscriminator") delete(allFields, "group") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewEntitySyncPolicyGroup() *EntitySyncPolicyGroup { p := new(EntitySyncPolicyGroup) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.EntitySyncPolicyGroup" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *EntitySyncPolicyGroup) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *EntitySyncPolicyGroup) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfEntitySyncPolicyGroupData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } type EntitySyncPolicyProjection struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* External identifier of the entity. */ EntityExtId *string `json:"entityExtId,omitempty"` /* Name of the entity. */ EntityName *string `json:"entityName,omitempty"` EntityType *SyncedEntityType `json:"entityType,omitempty"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` /* External identifier of the owner of the entity sync policy. */ OwnerExtId *string `json:"ownerExtId,omitempty"` /* External identifier of the remote domain manager. */ RemoteDomainManagerExtId *string `json:"remoteDomainManagerExtId,omitempty"` Status *EntitySyncStatus `json:"status,omitempty"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` } func (p *EntitySyncPolicyProjection) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias EntitySyncPolicyProjection // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *EntitySyncPolicyProjection) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias EntitySyncPolicyProjection known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewEntitySyncPolicyProjection() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.EntityExtId != nil { p.EntityExtId = known.EntityExtId } if known.EntityName != nil { p.EntityName = known.EntityName } if known.EntityType != nil { p.EntityType = known.EntityType } if known.ExtId != nil { p.ExtId = known.ExtId } if known.Links != nil { p.Links = known.Links } if known.OwnerExtId != nil { p.OwnerExtId = known.OwnerExtId } if known.RemoteDomainManagerExtId != nil { p.RemoteDomainManagerExtId = known.RemoteDomainManagerExtId } if known.Status != nil { p.Status = known.Status } if known.TenantId != nil { p.TenantId = known.TenantId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "entityExtId") delete(allFields, "entityName") delete(allFields, "entityType") delete(allFields, "extId") delete(allFields, "links") delete(allFields, "ownerExtId") delete(allFields, "remoteDomainManagerExtId") delete(allFields, "status") delete(allFields, "tenantId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewEntitySyncPolicyProjection() *EntitySyncPolicyProjection { p := new(EntitySyncPolicyProjection) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.EntitySyncPolicyProjection" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } type EntitySyncPolicyTimeValuePair struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` TimeStamp *int64 `json:"timeStamp,omitempty"` Value *int64 `json:"value,omitempty"` } func (p *EntitySyncPolicyTimeValuePair) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias EntitySyncPolicyTimeValuePair // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *EntitySyncPolicyTimeValuePair) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias EntitySyncPolicyTimeValuePair known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewEntitySyncPolicyTimeValuePair() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.TimeStamp != nil { p.TimeStamp = known.TimeStamp } if known.Value != nil { p.Value = known.Value } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "timeStamp") delete(allFields, "value") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewEntitySyncPolicyTimeValuePair() *EntitySyncPolicyTimeValuePair { p := new(EntitySyncPolicyTimeValuePair) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.EntitySyncPolicyTimeValuePair" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Sync status of the policy synced through entity sync policy. */ type EntitySyncStatus int const ( ENTITYSYNCSTATUS_UNKNOWN EntitySyncStatus = 0 ENTITYSYNCSTATUS_REDACTED EntitySyncStatus = 1 ENTITYSYNCSTATUS_IN_SYNC EntitySyncStatus = 2 ENTITYSYNCSTATUS_OUT_OF_SYNC EntitySyncStatus = 3 ENTITYSYNCSTATUS_SYNCING EntitySyncStatus = 4 ) // Returns the name of the enum given an ordinal number // // Deprecated: Please use GetName instead of name func (e *EntitySyncStatus) name(index int) string { names := [...]string{ "$UNKNOWN", "$REDACTED", "IN_SYNC", "OUT_OF_SYNC", "SYNCING", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the name of the enum func (e EntitySyncStatus) GetName() string { index := int(e) names := [...]string{ "$UNKNOWN", "$REDACTED", "IN_SYNC", "OUT_OF_SYNC", "SYNCING", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the enum type given a string value func (e *EntitySyncStatus) index(name string) EntitySyncStatus { names := [...]string{ "$UNKNOWN", "$REDACTED", "IN_SYNC", "OUT_OF_SYNC", "SYNCING", } for idx := range names { if names[idx] == name { return EntitySyncStatus(idx) } } return ENTITYSYNCSTATUS_UNKNOWN } func (e *EntitySyncStatus) UnmarshalJSON(b []byte) error { var enumStr string if err := json.Unmarshal(b, &enumStr); err != nil { return errors.New(fmt.Sprintf("Unable to unmarshal for EntitySyncStatus:%s", err)) } *e = e.index(enumStr) return nil } func (e *EntitySyncStatus) MarshalJSON() ([]byte, error) { b := bytes.NewBufferString(`"`) b.WriteString(e.name(int(*e))) b.WriteString(`"`) return b.Bytes(), nil } func (e EntitySyncStatus) Ref() *EntitySyncStatus { return &e } /* Fault Tolerance parameters for the entities. */ type FaultToleranceSpec struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` ReplicationFactor *ReplicationFactor `json:"replicationFactor"` } func (p *FaultToleranceSpec) MarshalJSON() ([]byte, error) { type FaultToleranceSpecProxy FaultToleranceSpec // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *FaultToleranceSpecProxy ReplicationFactor *ReplicationFactor `json:"replicationFactor,omitempty"` }{ FaultToleranceSpecProxy: (*FaultToleranceSpecProxy)(p), ReplicationFactor: p.ReplicationFactor, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *FaultToleranceSpec) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias FaultToleranceSpec known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewFaultToleranceSpec() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.ReplicationFactor != nil { p.ReplicationFactor = known.ReplicationFactor } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "replicationFactor") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewFaultToleranceSpec() *FaultToleranceSpec { p := new(FaultToleranceSpec) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.FaultToleranceSpec" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Floating IP configuration. */ type FloatingIp struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` IpAddress *import4.IPAddress `json:"ipAddress,omitempty"` /* Indicates whether to dynamically allocate a new floating IP address. If specified as true, the floating IP will be allocated from available floating IP addresses in the specified locations. Otherwise, the floating IP address specified in `ipAddress` field will be assigned to the VM. */ ShouldAllocateDynamically *bool `json:"shouldAllocateDynamically"` } func (p *FloatingIp) MarshalJSON() ([]byte, error) { type FloatingIpProxy FloatingIp // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *FloatingIpProxy ShouldAllocateDynamically *bool `json:"shouldAllocateDynamically,omitempty"` }{ FloatingIpProxy: (*FloatingIpProxy)(p), ShouldAllocateDynamically: p.ShouldAllocateDynamically, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *FloatingIp) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias FloatingIp known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewFloatingIp() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.IpAddress != nil { p.IpAddress = known.IpAddress } if known.ShouldAllocateDynamically != nil { p.ShouldAllocateDynamically = known.ShouldAllocateDynamically } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "ipAddress") delete(allFields, "shouldAllocateDynamically") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewFloatingIp() *FloatingIp { p := new(FloatingIp) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.FloatingIp" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} p.ShouldAllocateDynamically = new(bool) *p.ShouldAllocateDynamically = true return p } /* Floating IP address assignment. */ type FloatingIpAssociation struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* External identifier of the virtual NIC corresponding to which floating IP address is to be assigned. */ NicExtId *string `json:"nicExtId"` PrimaryFloatingIp *FloatingIp `json:"primaryFloatingIp,omitempty"` PrimaryTestFloatingIp *FloatingIp `json:"primaryTestFloatingIp,omitempty"` RecoveryFloatingIp *FloatingIp `json:"recoveryFloatingIp,omitempty"` RecoveryTestFloatingIp *FloatingIp `json:"recoveryTestFloatingIp,omitempty"` } func (p *FloatingIpAssociation) MarshalJSON() ([]byte, error) { type FloatingIpAssociationProxy FloatingIpAssociation // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *FloatingIpAssociationProxy NicExtId *string `json:"nicExtId,omitempty"` }{ FloatingIpAssociationProxy: (*FloatingIpAssociationProxy)(p), NicExtId: p.NicExtId, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *FloatingIpAssociation) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias FloatingIpAssociation known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewFloatingIpAssociation() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.NicExtId != nil { p.NicExtId = known.NicExtId } if known.PrimaryFloatingIp != nil { p.PrimaryFloatingIp = known.PrimaryFloatingIp } if known.PrimaryTestFloatingIp != nil { p.PrimaryTestFloatingIp = known.PrimaryTestFloatingIp } if known.RecoveryFloatingIp != nil { p.RecoveryFloatingIp = known.RecoveryFloatingIp } if known.RecoveryTestFloatingIp != nil { p.RecoveryTestFloatingIp = known.RecoveryTestFloatingIp } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "nicExtId") delete(allFields, "primaryFloatingIp") delete(allFields, "primaryTestFloatingIp") delete(allFields, "recoveryFloatingIp") delete(allFields, "recoveryTestFloatingIp") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewFloatingIpAssociation() *FloatingIpAssociation { p := new(FloatingIpAssociation) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.FloatingIpAssociation" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* REST response for all response codes in API path /datapolicies/v4.3/config/protection-policies/{protectionPolicyExtId}/consistency-rules/{extId} Get operation */ type GetConsistencyRuleApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfGetConsistencyRuleApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *GetConsistencyRuleApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias GetConsistencyRuleApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *GetConsistencyRuleApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias GetConsistencyRuleApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewGetConsistencyRuleApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewGetConsistencyRuleApiResponse() *GetConsistencyRuleApiResponse { p := new(GetConsistencyRuleApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.GetConsistencyRuleApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *GetConsistencyRuleApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *GetConsistencyRuleApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfGetConsistencyRuleApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/data-services-ip-mappings/{extId} Get operation */ type GetDataServicesIpMappingApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfGetDataServicesIpMappingApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *GetDataServicesIpMappingApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias GetDataServicesIpMappingApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *GetDataServicesIpMappingApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias GetDataServicesIpMappingApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewGetDataServicesIpMappingApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewGetDataServicesIpMappingApiResponse() *GetDataServicesIpMappingApiResponse { p := new(GetDataServicesIpMappingApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.GetDataServicesIpMappingApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *GetDataServicesIpMappingApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *GetDataServicesIpMappingApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfGetDataServicesIpMappingApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/entity-sync-policies/{extId} Get operation */ type GetEntitySyncPolicyApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfGetEntitySyncPolicyApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *GetEntitySyncPolicyApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias GetEntitySyncPolicyApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *GetEntitySyncPolicyApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias GetEntitySyncPolicyApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewGetEntitySyncPolicyApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewGetEntitySyncPolicyApiResponse() *GetEntitySyncPolicyApiResponse { p := new(GetEntitySyncPolicyApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.GetEntitySyncPolicyApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *GetEntitySyncPolicyApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *GetEntitySyncPolicyApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfGetEntitySyncPolicyApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/network-mappings/{extId} Get operation */ type GetNetworkMappingApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfGetNetworkMappingApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *GetNetworkMappingApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias GetNetworkMappingApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *GetNetworkMappingApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias GetNetworkMappingApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewGetNetworkMappingApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewGetNetworkMappingApiResponse() *GetNetworkMappingApiResponse { p := new(GetNetworkMappingApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.GetNetworkMappingApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *GetNetworkMappingApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *GetNetworkMappingApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfGetNetworkMappingApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/protection-policies/{extId} Get operation */ type GetProtectionPolicyApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfGetProtectionPolicyApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *GetProtectionPolicyApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias GetProtectionPolicyApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *GetProtectionPolicyApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias GetProtectionPolicyApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewGetProtectionPolicyApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewGetProtectionPolicyApiResponse() *GetProtectionPolicyApiResponse { p := new(GetProtectionPolicyApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.GetProtectionPolicyApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *GetProtectionPolicyApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *GetProtectionPolicyApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfGetProtectionPolicyApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{extId} Get operation */ type GetRecoveryPlanApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfGetRecoveryPlanApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *GetRecoveryPlanApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias GetRecoveryPlanApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *GetRecoveryPlanApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias GetRecoveryPlanApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewGetRecoveryPlanApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewGetRecoveryPlanApiResponse() *GetRecoveryPlanApiResponse { p := new(GetRecoveryPlanApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.GetRecoveryPlanApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *GetRecoveryPlanApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *GetRecoveryPlanApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfGetRecoveryPlanApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/recovery-settings/{extId} Get operation */ type GetRecoverySettingApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfGetRecoverySettingApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *GetRecoverySettingApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias GetRecoverySettingApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *GetRecoverySettingApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias GetRecoverySettingApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewGetRecoverySettingApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewGetRecoverySettingApiResponse() *GetRecoverySettingApiResponse { p := new(GetRecoverySettingApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.GetRecoverySettingApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *GetRecoverySettingApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *GetRecoverySettingApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfGetRecoverySettingApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/stages/{extId} Get operation */ type GetRecoveryStageApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfGetRecoveryStageApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *GetRecoveryStageApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias GetRecoveryStageApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *GetRecoveryStageApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias GetRecoveryStageApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewGetRecoveryStageApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewGetRecoveryStageApiResponse() *GetRecoveryStageApiResponse { p := new(GetRecoveryStageApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.GetRecoveryStageApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *GetRecoveryStageApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *GetRecoveryStageApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfGetRecoveryStageApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/storage-policies/{extId} Get operation */ type GetStoragePolicyApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfGetStoragePolicyApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *GetStoragePolicyApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias GetStoragePolicyApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *GetStoragePolicyApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias GetStoragePolicyApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewGetStoragePolicyApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewGetStoragePolicyApiResponse() *GetStoragePolicyApiResponse { p := new(GetStoragePolicyApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.GetStoragePolicyApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *GetStoragePolicyApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *GetStoragePolicyApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfGetStoragePolicyApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* IP configuration of the subnet. */ type IPConfig struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` Ipv4 *IPv4Config `json:"ipv4"` } func (p *IPConfig) MarshalJSON() ([]byte, error) { type IPConfigProxy IPConfig // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *IPConfigProxy Ipv4 *IPv4Config `json:"ipv4,omitempty"` }{ IPConfigProxy: (*IPConfigProxy)(p), Ipv4: p.Ipv4, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *IPConfig) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias IPConfig known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewIPConfig() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.Ipv4 != nil { p.Ipv4 = known.Ipv4 } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "ipv4") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewIPConfig() *IPConfig { p := new(IPConfig) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.IPConfig" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* IPv4 configuration of the subnet. Within `ipPool`, the prefix length for exact IP addresses must be 32. */ type IPv4Config struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* Subnet gateway IP address. */ DefaultGatewayIp *string `json:"defaultGatewayIp,omitempty"` /* DNS Servers IP addresses. */ DomainNameServers []string `json:"domainNameServers,omitempty"` /* Domain Name Servers suffixes. */ DomainSearchSuffixes []string `json:"domainSearchSuffixes,omitempty"` IpPool *import5.IPv4Pool `json:"ipPool,omitempty"` /* Network IP address. */ NetworkIpAddress *string `json:"networkIpAddress,omitempty"` /* Subnet prefix length. */ PrefixLength *int `json:"prefixLength,omitempty"` } func (p *IPv4Config) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias IPv4Config // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *IPv4Config) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias IPv4Config known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewIPv4Config() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DefaultGatewayIp != nil { p.DefaultGatewayIp = known.DefaultGatewayIp } if known.DomainNameServers != nil { p.DomainNameServers = known.DomainNameServers } if known.DomainSearchSuffixes != nil { p.DomainSearchSuffixes = known.DomainSearchSuffixes } if known.IpPool != nil { p.IpPool = known.IpPool } if known.NetworkIpAddress != nil { p.NetworkIpAddress = known.NetworkIpAddress } if known.PrefixLength != nil { p.PrefixLength = known.PrefixLength } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "defaultGatewayIp") delete(allFields, "domainNameServers") delete(allFields, "domainSearchSuffixes") delete(allFields, "ipPool") delete(allFields, "networkIpAddress") delete(allFields, "prefixLength") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewIPv4Config() *IPv4Config { p := new(IPv4Config) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.IPv4Config" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* In guest script. */ type InGuestScriptExecutionConfig struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* Enable in-guest script execution for the VM. By default, the in-guest script execution is disabled. */ IsEnabled *bool `json:"isEnabled"` /* Maximum time in seconds to wait for the in-guest script execution to complete. */ TimeoutSecs *int `json:"timeoutSecs,omitempty"` } func (p *InGuestScriptExecutionConfig) MarshalJSON() ([]byte, error) { type InGuestScriptExecutionConfigProxy InGuestScriptExecutionConfig // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *InGuestScriptExecutionConfigProxy IsEnabled *bool `json:"isEnabled,omitempty"` }{ InGuestScriptExecutionConfigProxy: (*InGuestScriptExecutionConfigProxy)(p), IsEnabled: p.IsEnabled, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *InGuestScriptExecutionConfig) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias InGuestScriptExecutionConfig known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewInGuestScriptExecutionConfig() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.IsEnabled != nil { p.IsEnabled = known.IsEnabled } if known.TimeoutSecs != nil { p.TimeoutSecs = known.TimeoutSecs } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "isEnabled") delete(allFields, "timeoutSecs") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewInGuestScriptExecutionConfig() *InGuestScriptExecutionConfig { p := new(InGuestScriptExecutionConfig) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.InGuestScriptExecutionConfig" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} p.TimeoutSecs = new(int) *p.TimeoutSecs = 120 return p } /* IP address assignment. */ type IpMapping struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* External identifier of the network mapping for which this IP mapping is applicable. */ NetworkMappingExtId *string `json:"networkMappingExtId"` PrimaryIp *import4.IPAddress `json:"primaryIp"` PrimaryTestIp *import4.IPAddress `json:"primaryTestIp,omitempty"` RecoveryIp *import4.IPAddress `json:"recoveryIp"` RecoveryTestIp *import4.IPAddress `json:"recoveryTestIp,omitempty"` } func (p *IpMapping) MarshalJSON() ([]byte, error) { type IpMappingProxy IpMapping // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *IpMappingProxy NetworkMappingExtId *string `json:"networkMappingExtId,omitempty"` PrimaryIp *import4.IPAddress `json:"primaryIp,omitempty"` RecoveryIp *import4.IPAddress `json:"recoveryIp,omitempty"` }{ IpMappingProxy: (*IpMappingProxy)(p), NetworkMappingExtId: p.NetworkMappingExtId, PrimaryIp: p.PrimaryIp, RecoveryIp: p.RecoveryIp, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *IpMapping) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias IpMapping known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewIpMapping() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.NetworkMappingExtId != nil { p.NetworkMappingExtId = known.NetworkMappingExtId } if known.PrimaryIp != nil { p.PrimaryIp = known.PrimaryIp } if known.PrimaryTestIp != nil { p.PrimaryTestIp = known.PrimaryTestIp } if known.RecoveryIp != nil { p.RecoveryIp = known.RecoveryIp } if known.RecoveryTestIp != nil { p.RecoveryTestIp = known.RecoveryTestIp } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "networkMappingExtId") delete(allFields, "primaryIp") delete(allFields, "primaryTestIp") delete(allFields, "recoveryIp") delete(allFields, "recoveryTestIp") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewIpMapping() *IpMapping { p := new(IpMapping) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.IpMapping" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* iSCSI specific setting to be configured on the recovered Volume Group. Target secret is mandatory if authentication type is `CHAP`. */ type IscsiFeatures struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` EnabledAuthentication *import6.AuthenticationType `json:"enabledAuthentication"` /* CHAP secret to be configured for authentication. */ Secret *string `json:"secret,omitempty"` } func (p *IscsiFeatures) MarshalJSON() ([]byte, error) { type IscsiFeaturesProxy IscsiFeatures // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *IscsiFeaturesProxy EnabledAuthentication *import6.AuthenticationType `json:"enabledAuthentication,omitempty"` }{ IscsiFeaturesProxy: (*IscsiFeaturesProxy)(p), EnabledAuthentication: p.EnabledAuthentication, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *IscsiFeatures) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias IscsiFeatures known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewIscsiFeatures() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.EnabledAuthentication != nil { p.EnabledAuthentication = known.EnabledAuthentication } if known.Secret != nil { p.Secret = known.Secret } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "enabledAuthentication") delete(allFields, "secret") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewIscsiFeatures() *IscsiFeatures { p := new(IscsiFeatures) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.IscsiFeatures" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* A simple retention scheme for the policy. If you set the retention number to n, the policy retains the n recent recovery points. */ type LinearRetention struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* Specifies the number of recovery points to retain on the local location. */ Local *int `json:"local"` /* Specifies the number of recovery points to retain on the remote location. */ Remote *int `json:"remote,omitempty"` } func (p *LinearRetention) MarshalJSON() ([]byte, error) { type LinearRetentionProxy LinearRetention // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *LinearRetentionProxy Local *int `json:"local,omitempty"` }{ LinearRetentionProxy: (*LinearRetentionProxy)(p), Local: p.Local, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *LinearRetention) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias LinearRetention known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewLinearRetention() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.Local != nil { p.Local = known.Local } if known.Remote != nil { p.Remote = known.Remote } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "local") delete(allFields, "remote") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewLinearRetention() *LinearRetention { p := new(LinearRetention) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.LinearRetention" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* REST response for all response codes in API path /datapolicies/v4.3/config/protection-policies/{protectionPolicyExtId}/consistency-rules Get operation */ type ListConsistencyRulesApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfListConsistencyRulesApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *ListConsistencyRulesApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias ListConsistencyRulesApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *ListConsistencyRulesApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias ListConsistencyRulesApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewListConsistencyRulesApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewListConsistencyRulesApiResponse() *ListConsistencyRulesApiResponse { p := new(ListConsistencyRulesApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.ListConsistencyRulesApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *ListConsistencyRulesApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *ListConsistencyRulesApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfListConsistencyRulesApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/data-services-ip-mappings Get operation */ type ListDataServicesIpMappingsApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfListDataServicesIpMappingsApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *ListDataServicesIpMappingsApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias ListDataServicesIpMappingsApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *ListDataServicesIpMappingsApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias ListDataServicesIpMappingsApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewListDataServicesIpMappingsApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewListDataServicesIpMappingsApiResponse() *ListDataServicesIpMappingsApiResponse { p := new(ListDataServicesIpMappingsApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.ListDataServicesIpMappingsApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *ListDataServicesIpMappingsApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *ListDataServicesIpMappingsApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfListDataServicesIpMappingsApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/entity-sync-policies Get operation */ type ListEntitySyncPoliciesApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfListEntitySyncPoliciesApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *ListEntitySyncPoliciesApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias ListEntitySyncPoliciesApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *ListEntitySyncPoliciesApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias ListEntitySyncPoliciesApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewListEntitySyncPoliciesApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewListEntitySyncPoliciesApiResponse() *ListEntitySyncPoliciesApiResponse { p := new(ListEntitySyncPoliciesApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.ListEntitySyncPoliciesApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *ListEntitySyncPoliciesApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *ListEntitySyncPoliciesApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfListEntitySyncPoliciesApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/network-mappings Get operation */ type ListNetworkMappingsApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfListNetworkMappingsApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *ListNetworkMappingsApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias ListNetworkMappingsApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *ListNetworkMappingsApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias ListNetworkMappingsApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewListNetworkMappingsApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewListNetworkMappingsApiResponse() *ListNetworkMappingsApiResponse { p := new(ListNetworkMappingsApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.ListNetworkMappingsApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *ListNetworkMappingsApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *ListNetworkMappingsApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfListNetworkMappingsApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/protection-policies Get operation */ type ListProtectionPoliciesApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfListProtectionPoliciesApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *ListProtectionPoliciesApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias ListProtectionPoliciesApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *ListProtectionPoliciesApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias ListProtectionPoliciesApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewListProtectionPoliciesApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewListProtectionPoliciesApiResponse() *ListProtectionPoliciesApiResponse { p := new(ListProtectionPoliciesApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.ListProtectionPoliciesApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *ListProtectionPoliciesApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *ListProtectionPoliciesApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfListProtectionPoliciesApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans Get operation */ type ListRecoveryPlansApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfListRecoveryPlansApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *ListRecoveryPlansApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias ListRecoveryPlansApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *ListRecoveryPlansApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias ListRecoveryPlansApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewListRecoveryPlansApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewListRecoveryPlansApiResponse() *ListRecoveryPlansApiResponse { p := new(ListRecoveryPlansApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.ListRecoveryPlansApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *ListRecoveryPlansApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *ListRecoveryPlansApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfListRecoveryPlansApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/recovery-settings Get operation */ type ListRecoverySettingsApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfListRecoverySettingsApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *ListRecoverySettingsApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias ListRecoverySettingsApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *ListRecoverySettingsApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias ListRecoverySettingsApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewListRecoverySettingsApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewListRecoverySettingsApiResponse() *ListRecoverySettingsApiResponse { p := new(ListRecoverySettingsApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.ListRecoverySettingsApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *ListRecoverySettingsApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *ListRecoverySettingsApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfListRecoverySettingsApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/stages Get operation */ type ListRecoveryStagesApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfListRecoveryStagesApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *ListRecoveryStagesApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias ListRecoveryStagesApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *ListRecoveryStagesApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias ListRecoveryStagesApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewListRecoveryStagesApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewListRecoveryStagesApiResponse() *ListRecoveryStagesApiResponse { p := new(ListRecoveryStagesApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.ListRecoveryStagesApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *ListRecoveryStagesApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *ListRecoveryStagesApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfListRecoveryStagesApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/storage-policies Get operation */ type ListStoragePoliciesApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfListStoragePoliciesApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *ListStoragePoliciesApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias ListStoragePoliciesApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *ListStoragePoliciesApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias ListStoragePoliciesApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewListStoragePoliciesApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewListStoragePoliciesApiResponse() *ListStoragePoliciesApiResponse { p := new(ListStoragePoliciesApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.ListStoragePoliciesApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *ListStoragePoliciesApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *ListStoragePoliciesApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfListStoragePoliciesApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* Configuration for MST-based replication sublocation, which allows recovery points to be stored in a Recovery Point Store accessible via MST. */ type Mst struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* External identifier of the Recovery Point Repository, accessible via MST. This field is deprecated. Use recoveryPointStoreExtId instead. */ RecoveryPointRepositoryExtId *string `json:"recoveryPointRepositoryExtId,omitempty"` /* External identifier of the Recovery Point Store, accessible via MST. */ RecoveryPointStoreExtId *string `json:"recoveryPointStoreExtId,omitempty"` } func (p *Mst) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias Mst // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *Mst) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias Mst known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewMst() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.RecoveryPointRepositoryExtId != nil { p.RecoveryPointRepositoryExtId = known.RecoveryPointRepositoryExtId } if known.RecoveryPointStoreExtId != nil { p.RecoveryPointStoreExtId = known.RecoveryPointStoreExtId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "recoveryPointRepositoryExtId") delete(allFields, "recoveryPointStoreExtId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewMst() *Mst { p := new(Mst) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.Mst" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Network configuration. VPC is required if the subnet is an overlay network. */ type NetworkConfig struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` IpConfig *IPConfig `json:"ipConfig,omitempty"` /* External identifier of the subnet. Only one of `subnetExtId` or `subnetName` may be specified at a time. */ SubnetExtId *string `json:"subnetExtId,omitempty"` /* Name of the subnet or port group. Exactly one of extId or name is required. */ SubnetName *string `json:"subnetName,omitempty"` Vpc *EntityReference `json:"vpc,omitempty"` } func (p *NetworkConfig) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias NetworkConfig // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *NetworkConfig) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias NetworkConfig known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewNetworkConfig() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.IpConfig != nil { p.IpConfig = known.IpConfig } if known.SubnetExtId != nil { p.SubnetExtId = known.SubnetExtId } if known.SubnetName != nil { p.SubnetName = known.SubnetName } if known.Vpc != nil { p.Vpc = known.Vpc } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "ipConfig") delete(allFields, "subnetExtId") delete(allFields, "subnetName") delete(allFields, "vpc") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewNetworkConfig() *NetworkConfig { p := new(NetworkConfig) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.NetworkConfig" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Mapping between networks on primary and recovery locations. This mapping will be used to create virtual NICs on failover or failback.
During a failover from primary location to recovery location, virtual NICs on the `primaryNetwork` will be recreated on the `recoveryNetwork` if failover action is `PLANNED_FAILOVER`, `UNPLANNED_FAILOVER` or the `recoveryTestNetwork` if failover action is `TEST_FAILOVER`.
During failback, virtual NICs on the `recoveryNetwork` will be recreated on the `primaryNetwork` if the failover action is `PLANNED_FAILOVER`, `UNPLANNED_FAILOVER` or `primaryTestNetwork` if the failover action is `TEST_FAILOVER`.
. */ type NetworkMapping struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` /* Indicates whether the static IPs of recovered VMs should be mapped according to the target network and configured inside the guest VMs. When specified as false, VMs may recover with any IP address allocated by the DHCP server corresponding to the target network. */ IsIpMappingEnabled *bool `json:"isIpMappingEnabled,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` PrimaryNetwork *NetworkConfig `json:"primaryNetwork"` PrimaryTestNetwork *NetworkConfig `json:"primaryTestNetwork,omitempty"` RecoveryNetwork *NetworkConfig `json:"recoveryNetwork"` RecoveryTestNetwork *NetworkConfig `json:"recoveryTestNetwork,omitempty"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` } func (p *NetworkMapping) MarshalJSON() ([]byte, error) { type NetworkMappingProxy NetworkMapping // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *NetworkMappingProxy PrimaryNetwork *NetworkConfig `json:"primaryNetwork,omitempty"` RecoveryNetwork *NetworkConfig `json:"recoveryNetwork,omitempty"` }{ NetworkMappingProxy: (*NetworkMappingProxy)(p), PrimaryNetwork: p.PrimaryNetwork, RecoveryNetwork: p.RecoveryNetwork, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *NetworkMapping) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias NetworkMapping known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewNetworkMapping() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.ExtId != nil { p.ExtId = known.ExtId } if known.IsIpMappingEnabled != nil { p.IsIpMappingEnabled = known.IsIpMappingEnabled } if known.Links != nil { p.Links = known.Links } if known.PrimaryNetwork != nil { p.PrimaryNetwork = known.PrimaryNetwork } if known.PrimaryTestNetwork != nil { p.PrimaryTestNetwork = known.PrimaryTestNetwork } if known.RecoveryNetwork != nil { p.RecoveryNetwork = known.RecoveryNetwork } if known.RecoveryTestNetwork != nil { p.RecoveryTestNetwork = known.RecoveryTestNetwork } if known.TenantId != nil { p.TenantId = known.TenantId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "extId") delete(allFields, "isIpMappingEnabled") delete(allFields, "links") delete(allFields, "primaryNetwork") delete(allFields, "primaryTestNetwork") delete(allFields, "recoveryNetwork") delete(allFields, "recoveryTestNetwork") delete(allFields, "tenantId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewNetworkMapping() *NetworkMapping { p := new(NetworkMapping) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.NetworkMapping" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} p.IsIpMappingEnabled = new(bool) *p.IsIpMappingEnabled = false return p } type NetworkMappingProjection struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` /* Indicates whether the static IPs of recovered VMs should be mapped according to the target network and configured inside the guest VMs. When specified as false, VMs may recover with any IP address allocated by the DHCP server corresponding to the target network. */ IsIpMappingEnabled *bool `json:"isIpMappingEnabled,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` PrimaryNetwork *NetworkConfig `json:"primaryNetwork"` PrimaryTestNetwork *NetworkConfig `json:"primaryTestNetwork,omitempty"` RecoveryNetwork *NetworkConfig `json:"recoveryNetwork"` RecoveryTestNetwork *NetworkConfig `json:"recoveryTestNetwork,omitempty"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` } func (p *NetworkMappingProjection) MarshalJSON() ([]byte, error) { type NetworkMappingProjectionProxy NetworkMappingProjection // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *NetworkMappingProjectionProxy PrimaryNetwork *NetworkConfig `json:"primaryNetwork,omitempty"` RecoveryNetwork *NetworkConfig `json:"recoveryNetwork,omitempty"` }{ NetworkMappingProjectionProxy: (*NetworkMappingProjectionProxy)(p), PrimaryNetwork: p.PrimaryNetwork, RecoveryNetwork: p.RecoveryNetwork, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *NetworkMappingProjection) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias NetworkMappingProjection known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewNetworkMappingProjection() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.ExtId != nil { p.ExtId = known.ExtId } if known.IsIpMappingEnabled != nil { p.IsIpMappingEnabled = known.IsIpMappingEnabled } if known.Links != nil { p.Links = known.Links } if known.PrimaryNetwork != nil { p.PrimaryNetwork = known.PrimaryNetwork } if known.PrimaryTestNetwork != nil { p.PrimaryTestNetwork = known.PrimaryTestNetwork } if known.RecoveryNetwork != nil { p.RecoveryNetwork = known.RecoveryNetwork } if known.RecoveryTestNetwork != nil { p.RecoveryTestNetwork = known.RecoveryTestNetwork } if known.TenantId != nil { p.TenantId = known.TenantId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "extId") delete(allFields, "isIpMappingEnabled") delete(allFields, "links") delete(allFields, "primaryNetwork") delete(allFields, "primaryTestNetwork") delete(allFields, "recoveryNetwork") delete(allFields, "recoveryTestNetwork") delete(allFields, "tenantId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewNetworkMappingProjection() *NetworkMappingProjection { p := new(NetworkMappingProjection) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.NetworkMappingProjection" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} p.IsIpMappingEnabled = new(bool) *p.IsIpMappingEnabled = false return p } /* List of Prism Element cluster external identifiers whose associated VMs and volume groups are protected. Only the primary location can have multiple clusters configured, while the other locations can specify only one cluster. Clusters must be specified for replication within the same Prism Central and cannot be specified for an MST type location. All clusters are considered if the cluster external identifier list is empty. */ type NutanixCluster struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* List of Prism Element cluster external identifiers whose associated VMs and volume groups are protected. Only the primary location can have multiple clusters configured, while the other locations can specify only one cluster. Clusters must be specified for replication within the same Prism Central and cannot be specified for an MST type location. All clusters are considered if the cluster external identifier list is empty. */ ClusterExtIds []string `json:"clusterExtIds,omitempty"` } func (p *NutanixCluster) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias NutanixCluster // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *NutanixCluster) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias NutanixCluster known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewNutanixCluster() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.ClusterExtIds != nil { p.ClusterExtIds = known.ClusterExtIds } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "clusterExtIds") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewNutanixCluster() *NutanixCluster { p := new(NutanixCluster) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.NutanixCluster" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Indicates whether it is a user-created Policy or created by the system. */ type PolicyType int const ( POLICYTYPE_UNKNOWN PolicyType = 0 POLICYTYPE_REDACTED PolicyType = 1 POLICYTYPE_USER PolicyType = 2 POLICYTYPE_SYSTEM PolicyType = 3 ) // Returns the name of the enum given an ordinal number // // Deprecated: Please use GetName instead of name func (e *PolicyType) name(index int) string { names := [...]string{ "$UNKNOWN", "$REDACTED", "USER", "SYSTEM", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the name of the enum func (e PolicyType) GetName() string { index := int(e) names := [...]string{ "$UNKNOWN", "$REDACTED", "USER", "SYSTEM", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the enum type given a string value func (e *PolicyType) index(name string) PolicyType { names := [...]string{ "$UNKNOWN", "$REDACTED", "USER", "SYSTEM", } for idx := range names { if names[idx] == name { return PolicyType(idx) } } return POLICYTYPE_UNKNOWN } func (e *PolicyType) UnmarshalJSON(b []byte) error { var enumStr string if err := json.Unmarshal(b, &enumStr); err != nil { return errors.New(fmt.Sprintf("Unable to unmarshal for PolicyType:%s", err)) } *e = e.index(enumStr) return nil } func (e *PolicyType) MarshalJSON() ([]byte, error) { b := bytes.NewBufferString(`"`) b.WriteString(e.name(int(*e))) b.WriteString(`"`) return b.Bytes(), nil } func (e PolicyType) Ref() *PolicyType { return &e } /* Power state. */ type PowerState int const ( POWERSTATE_UNKNOWN PowerState = 0 POWERSTATE_REDACTED PowerState = 1 POWERSTATE_ON PowerState = 2 POWERSTATE_OFF PowerState = 3 ) // Returns the name of the enum given an ordinal number // // Deprecated: Please use GetName instead of name func (e *PowerState) name(index int) string { names := [...]string{ "$UNKNOWN", "$REDACTED", "ON", "OFF", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the name of the enum func (e PowerState) GetName() string { index := int(e) names := [...]string{ "$UNKNOWN", "$REDACTED", "ON", "OFF", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the enum type given a string value func (e *PowerState) index(name string) PowerState { names := [...]string{ "$UNKNOWN", "$REDACTED", "ON", "OFF", } for idx := range names { if names[idx] == name { return PowerState(idx) } } return POWERSTATE_UNKNOWN } func (e *PowerState) UnmarshalJSON(b []byte) error { var enumStr string if err := json.Unmarshal(b, &enumStr); err != nil { return errors.New(fmt.Sprintf("Unable to unmarshal for PowerState:%s", err)) } *e = e.index(enumStr) return nil } func (e *PowerState) MarshalJSON() ([]byte, error) { b := bytes.NewBufferString(`"`) b.WriteString(e.name(int(*e))) b.WriteString(`"`) return b.Bytes(), nil } func (e PowerState) Ref() *PowerState { return &e } /* A protection policy automates the process of creating and replicating recovery points. When a protection policy is configured to create local recovery points, the request includes:
- The recovery point objective
- The retention policy
- The entities that need to be protected by specifying the categories in which they are tagged.
To automate recovery point replication, you can also specify the replication location(s). Only users with legacy roles, such as admin, can create a Cross-AZ protection policy. */ type ProtectionPolicy struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* Specifies the list of external identifiers of categories that must be added to the protection policy. This policy will protect any VM or volume group associated with this category. */ CategoryIds []string `json:"categoryIds,omitempty"` /* Description of the protection policy. */ Description *string `json:"description,omitempty"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` /* Manual deletion of recovery points created by this policy can be driven through a multi-party authorization workflow. Hence, multiple approvers would be required to grant approvals for the delete operation. */ IsApprovalPolicyNeeded *bool `json:"isApprovalPolicyNeeded,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` /* Name of the protection policy. */ Name *string `json:"name"` /* External identifier of the owner of the protection policy. */ OwnerExtId *string `json:"ownerExtId,omitempty"` /* Specifies the connections between various replication locations and its schedule. Connections from both source-to-target and target-to-source should be specified. */ ReplicationConfigurations []ReplicationConfiguration `json:"replicationConfigurations"` /* Indicates all the locations participating in the protection policy. You can specify up to 3 replication locations. */ ReplicationLocations []ReplicationLocation `json:"replicationLocations"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` } func (p *ProtectionPolicy) MarshalJSON() ([]byte, error) { type ProtectionPolicyProxy ProtectionPolicy // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *ProtectionPolicyProxy Name *string `json:"name,omitempty"` ReplicationConfigurations []ReplicationConfiguration `json:"replicationConfigurations,omitempty"` ReplicationLocations []ReplicationLocation `json:"replicationLocations,omitempty"` }{ ProtectionPolicyProxy: (*ProtectionPolicyProxy)(p), Name: p.Name, ReplicationConfigurations: p.ReplicationConfigurations, ReplicationLocations: p.ReplicationLocations, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *ProtectionPolicy) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias ProtectionPolicy known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewProtectionPolicy() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.CategoryIds != nil { p.CategoryIds = known.CategoryIds } if known.Description != nil { p.Description = known.Description } if known.ExtId != nil { p.ExtId = known.ExtId } if known.IsApprovalPolicyNeeded != nil { p.IsApprovalPolicyNeeded = known.IsApprovalPolicyNeeded } if known.Links != nil { p.Links = known.Links } if known.Name != nil { p.Name = known.Name } if known.OwnerExtId != nil { p.OwnerExtId = known.OwnerExtId } if known.ReplicationConfigurations != nil { p.ReplicationConfigurations = known.ReplicationConfigurations } if known.ReplicationLocations != nil { p.ReplicationLocations = known.ReplicationLocations } if known.TenantId != nil { p.TenantId = known.TenantId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "categoryIds") delete(allFields, "description") delete(allFields, "extId") delete(allFields, "isApprovalPolicyNeeded") delete(allFields, "links") delete(allFields, "name") delete(allFields, "ownerExtId") delete(allFields, "replicationConfigurations") delete(allFields, "replicationLocations") delete(allFields, "tenantId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewProtectionPolicy() *ProtectionPolicy { p := new(ProtectionPolicy) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.ProtectionPolicy" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } type ProtectionPolicyProjection struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* Specifies the list of external identifiers of categories that must be added to the protection policy. This policy will protect any VM or volume group associated with this category. */ CategoryIds []string `json:"categoryIds,omitempty"` /* Description of the protection policy. */ Description *string `json:"description,omitempty"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` /* Manual deletion of recovery points created by this policy can be driven through a multi-party authorization workflow. Hence, multiple approvers would be required to grant approvals for the delete operation. */ IsApprovalPolicyNeeded *bool `json:"isApprovalPolicyNeeded,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` /* Name of the protection policy. */ Name *string `json:"name"` /* External identifier of the owner of the protection policy. */ OwnerExtId *string `json:"ownerExtId,omitempty"` /* Specifies the connections between various replication locations and its schedule. Connections from both source-to-target and target-to-source should be specified. */ ReplicationConfigurations []ReplicationConfiguration `json:"replicationConfigurations"` /* Indicates all the locations participating in the protection policy. You can specify up to 3 replication locations. */ ReplicationLocations []ReplicationLocation `json:"replicationLocations"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` } func (p *ProtectionPolicyProjection) MarshalJSON() ([]byte, error) { type ProtectionPolicyProjectionProxy ProtectionPolicyProjection // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *ProtectionPolicyProjectionProxy Name *string `json:"name,omitempty"` ReplicationConfigurations []ReplicationConfiguration `json:"replicationConfigurations,omitempty"` ReplicationLocations []ReplicationLocation `json:"replicationLocations,omitempty"` }{ ProtectionPolicyProjectionProxy: (*ProtectionPolicyProjectionProxy)(p), Name: p.Name, ReplicationConfigurations: p.ReplicationConfigurations, ReplicationLocations: p.ReplicationLocations, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *ProtectionPolicyProjection) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias ProtectionPolicyProjection known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewProtectionPolicyProjection() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.CategoryIds != nil { p.CategoryIds = known.CategoryIds } if known.Description != nil { p.Description = known.Description } if known.ExtId != nil { p.ExtId = known.ExtId } if known.IsApprovalPolicyNeeded != nil { p.IsApprovalPolicyNeeded = known.IsApprovalPolicyNeeded } if known.Links != nil { p.Links = known.Links } if known.Name != nil { p.Name = known.Name } if known.OwnerExtId != nil { p.OwnerExtId = known.OwnerExtId } if known.ReplicationConfigurations != nil { p.ReplicationConfigurations = known.ReplicationConfigurations } if known.ReplicationLocations != nil { p.ReplicationLocations = known.ReplicationLocations } if known.TenantId != nil { p.TenantId = known.TenantId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "categoryIds") delete(allFields, "description") delete(allFields, "extId") delete(allFields, "isApprovalPolicyNeeded") delete(allFields, "links") delete(allFields, "name") delete(allFields, "ownerExtId") delete(allFields, "replicationConfigurations") delete(allFields, "replicationLocations") delete(allFields, "tenantId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewProtectionPolicyProjection() *ProtectionPolicyProjection { p := new(ProtectionPolicyProjection) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.ProtectionPolicyProjection" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Storage QOS parameters for the entities. */ type QosSpec struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* Throttled IOPS for the entities being governed. The block size for the IO is 32kB. */ ThrottledIops *int `json:"throttledIops"` } func (p *QosSpec) MarshalJSON() ([]byte, error) { type QosSpecProxy QosSpec // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *QosSpecProxy ThrottledIops *int `json:"throttledIops,omitempty"` }{ QosSpecProxy: (*QosSpecProxy)(p), ThrottledIops: p.ThrottledIops, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *QosSpec) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias QosSpec known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewQosSpec() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.ThrottledIops != nil { p.ThrottledIops = known.ThrottledIops } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "throttledIops") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewQosSpec() *QosSpec { p := new(QosSpec) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.QosSpec" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Recoverable entity type. */ type RecoverableEntityType int const ( RECOVERABLEENTITYTYPE_UNKNOWN RecoverableEntityType = 0 RECOVERABLEENTITYTYPE_REDACTED RecoverableEntityType = 1 RECOVERABLEENTITYTYPE_VM RecoverableEntityType = 2 RECOVERABLEENTITYTYPE_VOLUME_GROUP RecoverableEntityType = 3 ) // Returns the name of the enum given an ordinal number // // Deprecated: Please use GetName instead of name func (e *RecoverableEntityType) name(index int) string { names := [...]string{ "$UNKNOWN", "$REDACTED", "VM", "VOLUME_GROUP", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the name of the enum func (e RecoverableEntityType) GetName() string { index := int(e) names := [...]string{ "$UNKNOWN", "$REDACTED", "VM", "VOLUME_GROUP", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the enum type given a string value func (e *RecoverableEntityType) index(name string) RecoverableEntityType { names := [...]string{ "$UNKNOWN", "$REDACTED", "VM", "VOLUME_GROUP", } for idx := range names { if names[idx] == name { return RecoverableEntityType(idx) } } return RECOVERABLEENTITYTYPE_UNKNOWN } func (e *RecoverableEntityType) UnmarshalJSON(b []byte) error { var enumStr string if err := json.Unmarshal(b, &enumStr); err != nil { return errors.New(fmt.Sprintf("Unable to unmarshal for RecoverableEntityType:%s", err)) } *e = e.index(enumStr) return nil } func (e *RecoverableEntityType) MarshalJSON() ([]byte, error) { b := bytes.NewBufferString(`"`) b.WriteString(e.name(int(*e))) b.WriteString(`"`) return b.Bytes(), nil } func (e RecoverableEntityType) Ref() *RecoverableEntityType { return &e } /* A recovery plan orchestrates disaster recovery of protected VMs and volume groups on primary Nutanix clusters to secondary Nutanix clusters registered to the same or different Domain manager. */ type RecoveryPlan struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* Description of the recovery plan. */ Description *string `json:"description,omitempty"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` /* Indicates whether protection for the recovered VMs and Volume groups is currently paused as a result of post-failover behavior. */ IsProtectionPausedPostFailover *bool `json:"isProtectionPausedPostFailover,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` /* Name of the recovery plan. */ Name *string `json:"name"` /* External identifier of the owner of the protection policy. */ OwnerExtId *string `json:"ownerExtId,omitempty"` PrimaryLocation *DisasterRecoveryLocation `json:"primaryLocation"` RecoveryLocation *DisasterRecoveryLocation `json:"recoveryLocation"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` Witness *WitnessConfiguration `json:"witness,omitempty"` } func (p *RecoveryPlan) MarshalJSON() ([]byte, error) { type RecoveryPlanProxy RecoveryPlan // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *RecoveryPlanProxy Name *string `json:"name,omitempty"` PrimaryLocation *DisasterRecoveryLocation `json:"primaryLocation,omitempty"` RecoveryLocation *DisasterRecoveryLocation `json:"recoveryLocation,omitempty"` }{ RecoveryPlanProxy: (*RecoveryPlanProxy)(p), Name: p.Name, PrimaryLocation: p.PrimaryLocation, RecoveryLocation: p.RecoveryLocation, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *RecoveryPlan) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias RecoveryPlan known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewRecoveryPlan() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.Description != nil { p.Description = known.Description } if known.ExtId != nil { p.ExtId = known.ExtId } if known.IsProtectionPausedPostFailover != nil { p.IsProtectionPausedPostFailover = known.IsProtectionPausedPostFailover } if known.Links != nil { p.Links = known.Links } if known.Name != nil { p.Name = known.Name } if known.OwnerExtId != nil { p.OwnerExtId = known.OwnerExtId } if known.PrimaryLocation != nil { p.PrimaryLocation = known.PrimaryLocation } if known.RecoveryLocation != nil { p.RecoveryLocation = known.RecoveryLocation } if known.TenantId != nil { p.TenantId = known.TenantId } if known.Witness != nil { p.Witness = known.Witness } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "description") delete(allFields, "extId") delete(allFields, "isProtectionPausedPostFailover") delete(allFields, "links") delete(allFields, "name") delete(allFields, "ownerExtId") delete(allFields, "primaryLocation") delete(allFields, "recoveryLocation") delete(allFields, "tenantId") delete(allFields, "witness") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewRecoveryPlan() *RecoveryPlan { p := new(RecoveryPlan) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.RecoveryPlan" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } type RecoveryPlanProjection struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* Description of the recovery plan. */ Description *string `json:"description,omitempty"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` /* Indicates whether protection for the recovered VMs and Volume groups is currently paused as a result of post-failover behavior. */ IsProtectionPausedPostFailover *bool `json:"isProtectionPausedPostFailover,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` /* Name of the recovery plan. */ Name *string `json:"name"` /* External identifier of the owner of the protection policy. */ OwnerExtId *string `json:"ownerExtId,omitempty"` PrimaryLocation *DisasterRecoveryLocation `json:"primaryLocation"` RecoveryLocation *DisasterRecoveryLocation `json:"recoveryLocation"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` Witness *WitnessConfiguration `json:"witness,omitempty"` } func (p *RecoveryPlanProjection) MarshalJSON() ([]byte, error) { type RecoveryPlanProjectionProxy RecoveryPlanProjection // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *RecoveryPlanProjectionProxy Name *string `json:"name,omitempty"` PrimaryLocation *DisasterRecoveryLocation `json:"primaryLocation,omitempty"` RecoveryLocation *DisasterRecoveryLocation `json:"recoveryLocation,omitempty"` }{ RecoveryPlanProjectionProxy: (*RecoveryPlanProjectionProxy)(p), Name: p.Name, PrimaryLocation: p.PrimaryLocation, RecoveryLocation: p.RecoveryLocation, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *RecoveryPlanProjection) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias RecoveryPlanProjection known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewRecoveryPlanProjection() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.Description != nil { p.Description = known.Description } if known.ExtId != nil { p.ExtId = known.ExtId } if known.IsProtectionPausedPostFailover != nil { p.IsProtectionPausedPostFailover = known.IsProtectionPausedPostFailover } if known.Links != nil { p.Links = known.Links } if known.Name != nil { p.Name = known.Name } if known.OwnerExtId != nil { p.OwnerExtId = known.OwnerExtId } if known.PrimaryLocation != nil { p.PrimaryLocation = known.PrimaryLocation } if known.RecoveryLocation != nil { p.RecoveryLocation = known.RecoveryLocation } if known.TenantId != nil { p.TenantId = known.TenantId } if known.Witness != nil { p.Witness = known.Witness } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "description") delete(allFields, "extId") delete(allFields, "isProtectionPausedPostFailover") delete(allFields, "links") delete(allFields, "name") delete(allFields, "ownerExtId") delete(allFields, "primaryLocation") delete(allFields, "recoveryLocation") delete(allFields, "tenantId") delete(allFields, "witness") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewRecoveryPlanProjection() *RecoveryPlanProjection { p := new(RecoveryPlanProjection) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.RecoveryPlanProjection" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Recovery setting. */ type RecoverySetting struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` /* */ RecoverySettingItemDiscriminator_ *string `json:"$recoverySettingItemDiscriminator,omitempty"` /* Recovery setting to be applied to the VM(s) or Volume Group(s). */ RecoverySetting *OneOfRecoverySettingRecoverySetting `json:"recoverySetting"` Scope *RecoverySettingScope `json:"scope,omitempty"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` } func (p *RecoverySetting) MarshalJSON() ([]byte, error) { type RecoverySettingProxy RecoverySetting // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *RecoverySettingProxy RecoverySetting *OneOfRecoverySettingRecoverySetting `json:"recoverySetting,omitempty"` }{ RecoverySettingProxy: (*RecoverySettingProxy)(p), RecoverySetting: p.RecoverySetting, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *RecoverySetting) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias RecoverySetting known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewRecoverySetting() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.ExtId != nil { p.ExtId = known.ExtId } if known.Links != nil { p.Links = known.Links } if known.RecoverySettingItemDiscriminator_ != nil { p.RecoverySettingItemDiscriminator_ = known.RecoverySettingItemDiscriminator_ } if known.RecoverySetting != nil { p.RecoverySetting = known.RecoverySetting } if known.Scope != nil { p.Scope = known.Scope } if known.TenantId != nil { p.TenantId = known.TenantId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "extId") delete(allFields, "links") delete(allFields, "$recoverySettingItemDiscriminator") delete(allFields, "recoverySetting") delete(allFields, "scope") delete(allFields, "tenantId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewRecoverySetting() *RecoverySetting { p := new(RecoverySetting) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.RecoverySetting" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *RecoverySetting) GetRecoverySetting() interface{} { if nil == p.RecoverySetting { return nil } return p.RecoverySetting.GetValue() } func (p *RecoverySetting) SetRecoverySetting(v interface{}) error { if nil == p.RecoverySetting { p.RecoverySetting = NewOneOfRecoverySettingRecoverySetting() } e := p.RecoverySetting.SetValue(v) if nil == e { if nil == p.RecoverySettingItemDiscriminator_ { p.RecoverySettingItemDiscriminator_ = new(string) } *p.RecoverySettingItemDiscriminator_ = *p.RecoverySetting.Discriminator } return e } type RecoverySettingProjection struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` RecoverySettingItemDiscriminator_ *string `json:"$recoverySettingItemDiscriminator,omitempty"` /* Recovery setting to be applied to the VM(s) or Volume Group(s). */ RecoverySetting *OneOfRecoverySettingProjectionRecoverySetting `json:"recoverySetting"` Scope *RecoverySettingScope `json:"scope,omitempty"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` } func (p *RecoverySettingProjection) MarshalJSON() ([]byte, error) { type RecoverySettingProjectionProxy RecoverySettingProjection // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *RecoverySettingProjectionProxy RecoverySetting *OneOfRecoverySettingProjectionRecoverySetting `json:"recoverySetting,omitempty"` }{ RecoverySettingProjectionProxy: (*RecoverySettingProjectionProxy)(p), RecoverySetting: p.RecoverySetting, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *RecoverySettingProjection) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias RecoverySettingProjection known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewRecoverySettingProjection() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.ExtId != nil { p.ExtId = known.ExtId } if known.Links != nil { p.Links = known.Links } if known.RecoverySettingItemDiscriminator_ != nil { p.RecoverySettingItemDiscriminator_ = known.RecoverySettingItemDiscriminator_ } if known.RecoverySetting != nil { p.RecoverySetting = known.RecoverySetting } if known.Scope != nil { p.Scope = known.Scope } if known.TenantId != nil { p.TenantId = known.TenantId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "extId") delete(allFields, "links") delete(allFields, "$recoverySettingItemDiscriminator") delete(allFields, "recoverySetting") delete(allFields, "scope") delete(allFields, "tenantId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewRecoverySettingProjection() *RecoverySettingProjection { p := new(RecoverySettingProjection) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.RecoverySettingProjection" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Recovery setting scope. scope is a read only field. */ type RecoverySettingScope int const ( RECOVERYSETTINGSCOPE_UNKNOWN RecoverySettingScope = 0 RECOVERYSETTINGSCOPE_REDACTED RecoverySettingScope = 1 RECOVERYSETTINGSCOPE_VM RecoverySettingScope = 2 RECOVERYSETTINGSCOPE_VM_CATEGORY RecoverySettingScope = 3 RECOVERYSETTINGSCOPE_VOLUME_GROUP RecoverySettingScope = 4 ) // Returns the name of the enum given an ordinal number // // Deprecated: Please use GetName instead of name func (e *RecoverySettingScope) name(index int) string { names := [...]string{ "$UNKNOWN", "$REDACTED", "VM", "VM_CATEGORY", "VOLUME_GROUP", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the name of the enum func (e RecoverySettingScope) GetName() string { index := int(e) names := [...]string{ "$UNKNOWN", "$REDACTED", "VM", "VM_CATEGORY", "VOLUME_GROUP", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the enum type given a string value func (e *RecoverySettingScope) index(name string) RecoverySettingScope { names := [...]string{ "$UNKNOWN", "$REDACTED", "VM", "VM_CATEGORY", "VOLUME_GROUP", } for idx := range names { if names[idx] == name { return RecoverySettingScope(idx) } } return RECOVERYSETTINGSCOPE_UNKNOWN } func (e *RecoverySettingScope) UnmarshalJSON(b []byte) error { var enumStr string if err := json.Unmarshal(b, &enumStr); err != nil { return errors.New(fmt.Sprintf("Unable to unmarshal for RecoverySettingScope:%s", err)) } *e = e.index(enumStr) return nil } func (e *RecoverySettingScope) MarshalJSON() ([]byte, error) { b := bytes.NewBufferString(`"`) b.WriteString(e.name(int(*e))) b.WriteString(`"`) return b.Bytes(), nil } func (e RecoverySettingScope) Ref() *RecoverySettingScope { return &e } /* Recovery stages defines a group of VMs or a group of Volumes to be recovered. */ type RecoveryStage struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* List of external identifiers of categories for which entities of {entityType} are to be recovered in the Recovery stage. */ CategoryExtIds []string `json:"categoryExtIds,omitempty"` /* List of external references of entities of type {entityType} to be recovered in the Recovery stage. */ Entities []EntityReference `json:"entities,omitempty"` EntityType *RecoverableEntityType `json:"entityType"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` /* List of actions to be executed after completion of the stage. */ PostActions []StageAction `json:"postActions,omitempty"` /* Recovery priority of the Stage. This determines the shutdown and power-on order of the VMs. Recovery plan will power on VMs with priority 1 and then VMs with priority 2 and so on. Similarly during a Planned failover (migration) VMs with priority order 5 will be shutdown before VMs with priority order 4 and so on. Only priority value of 1 is acceptable for {entityType} VOLUME_GROUP. */ Priority *int `json:"priority,omitempty"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` } func (p *RecoveryStage) MarshalJSON() ([]byte, error) { type RecoveryStageProxy RecoveryStage // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *RecoveryStageProxy EntityType *RecoverableEntityType `json:"entityType,omitempty"` }{ RecoveryStageProxy: (*RecoveryStageProxy)(p), EntityType: p.EntityType, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *RecoveryStage) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias RecoveryStage known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewRecoveryStage() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.CategoryExtIds != nil { p.CategoryExtIds = known.CategoryExtIds } if known.Entities != nil { p.Entities = known.Entities } if known.EntityType != nil { p.EntityType = known.EntityType } if known.ExtId != nil { p.ExtId = known.ExtId } if known.Links != nil { p.Links = known.Links } if known.PostActions != nil { p.PostActions = known.PostActions } if known.Priority != nil { p.Priority = known.Priority } if known.TenantId != nil { p.TenantId = known.TenantId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "categoryExtIds") delete(allFields, "entities") delete(allFields, "entityType") delete(allFields, "extId") delete(allFields, "links") delete(allFields, "postActions") delete(allFields, "priority") delete(allFields, "tenantId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewRecoveryStage() *RecoveryStage { p := new(RecoveryStage) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.RecoveryStage" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} p.Priority = new(int) *p.Priority = 1 return p } type RecoveryStageProjection struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* List of external identifiers of categories for which entities of {entityType} are to be recovered in the Recovery stage. */ CategoryExtIds []string `json:"categoryExtIds,omitempty"` /* List of external references of entities of type {entityType} to be recovered in the Recovery stage. */ Entities []EntityReference `json:"entities,omitempty"` EntityType *RecoverableEntityType `json:"entityType"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` /* List of actions to be executed after completion of the stage. */ PostActions []StageAction `json:"postActions,omitempty"` /* Recovery priority of the Stage. This determines the shutdown and power-on order of the VMs. Recovery plan will power on VMs with priority 1 and then VMs with priority 2 and so on. Similarly during a Planned failover (migration) VMs with priority order 5 will be shutdown before VMs with priority order 4 and so on. Only priority value of 1 is acceptable for {entityType} VOLUME_GROUP. */ Priority *int `json:"priority,omitempty"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` } func (p *RecoveryStageProjection) MarshalJSON() ([]byte, error) { type RecoveryStageProjectionProxy RecoveryStageProjection // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *RecoveryStageProjectionProxy EntityType *RecoverableEntityType `json:"entityType,omitempty"` }{ RecoveryStageProjectionProxy: (*RecoveryStageProjectionProxy)(p), EntityType: p.EntityType, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *RecoveryStageProjection) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias RecoveryStageProjection known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewRecoveryStageProjection() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.CategoryExtIds != nil { p.CategoryExtIds = known.CategoryExtIds } if known.Entities != nil { p.Entities = known.Entities } if known.EntityType != nil { p.EntityType = known.EntityType } if known.ExtId != nil { p.ExtId = known.ExtId } if known.Links != nil { p.Links = known.Links } if known.PostActions != nil { p.PostActions = known.PostActions } if known.Priority != nil { p.Priority = known.Priority } if known.TenantId != nil { p.TenantId = known.TenantId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "categoryExtIds") delete(allFields, "entities") delete(allFields, "entityType") delete(allFields, "extId") delete(allFields, "links") delete(allFields, "postActions") delete(allFields, "priority") delete(allFields, "tenantId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewRecoveryStageProjection() *RecoveryStageProjection { p := new(RecoveryStageProjection) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.RecoveryStageProjection" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} p.Priority = new(int) *p.Priority = 1 return p } /* Specifies the connections between various replication locations and its schedule. Connections from both source-to-target and target-to-source should be specified. */ type ReplicationConfiguration struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* Label of the source location from the replication locations list, where the entity will be replicated. */ RemoteLocationLabel *string `json:"remoteLocationLabel,omitempty"` Schedule *Schedule `json:"schedule"` /* Label of the source location from the replication locations list, where the entity is running. The location of type MST can not be specified as the replication source. */ SourceLocationLabel *string `json:"sourceLocationLabel"` } func (p *ReplicationConfiguration) MarshalJSON() ([]byte, error) { type ReplicationConfigurationProxy ReplicationConfiguration // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *ReplicationConfigurationProxy Schedule *Schedule `json:"schedule,omitempty"` SourceLocationLabel *string `json:"sourceLocationLabel,omitempty"` }{ ReplicationConfigurationProxy: (*ReplicationConfigurationProxy)(p), Schedule: p.Schedule, SourceLocationLabel: p.SourceLocationLabel, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *ReplicationConfiguration) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias ReplicationConfiguration known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewReplicationConfiguration() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.RemoteLocationLabel != nil { p.RemoteLocationLabel = known.RemoteLocationLabel } if known.Schedule != nil { p.Schedule = known.Schedule } if known.SourceLocationLabel != nil { p.SourceLocationLabel = known.SourceLocationLabel } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "remoteLocationLabel") delete(allFields, "schedule") delete(allFields, "sourceLocationLabel") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewReplicationConfiguration() *ReplicationConfiguration { p := new(ReplicationConfiguration) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.ReplicationConfiguration" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Number of data copies for entities governed by the Storage Policy. */ type ReplicationFactor int const ( REPLICATIONFACTOR_UNKNOWN ReplicationFactor = 0 REPLICATIONFACTOR_REDACTED ReplicationFactor = 1 REPLICATIONFACTOR_TWO ReplicationFactor = 2 REPLICATIONFACTOR_THREE ReplicationFactor = 3 REPLICATIONFACTOR_SYSTEM_DERIVED ReplicationFactor = 4 ) // Returns the name of the enum given an ordinal number // // Deprecated: Please use GetName instead of name func (e *ReplicationFactor) name(index int) string { names := [...]string{ "$UNKNOWN", "$REDACTED", "TWO", "THREE", "SYSTEM_DERIVED", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the name of the enum func (e ReplicationFactor) GetName() string { index := int(e) names := [...]string{ "$UNKNOWN", "$REDACTED", "TWO", "THREE", "SYSTEM_DERIVED", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the enum type given a string value func (e *ReplicationFactor) index(name string) ReplicationFactor { names := [...]string{ "$UNKNOWN", "$REDACTED", "TWO", "THREE", "SYSTEM_DERIVED", } for idx := range names { if names[idx] == name { return ReplicationFactor(idx) } } return REPLICATIONFACTOR_UNKNOWN } func (e *ReplicationFactor) UnmarshalJSON(b []byte) error { var enumStr string if err := json.Unmarshal(b, &enumStr); err != nil { return errors.New(fmt.Sprintf("Unable to unmarshal for ReplicationFactor:%s", err)) } *e = e.index(enumStr) return nil } func (e *ReplicationFactor) MarshalJSON() ([]byte, error) { b := bytes.NewBufferString(`"`) b.WriteString(e.name(int(*e))) b.WriteString(`"`) return b.Bytes(), nil } func (e ReplicationFactor) Ref() *ReplicationFactor { return &e } /* Indicates all the locations participating in the protection policy. You can specify up to 3 replication locations. */ type ReplicationLocation struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* External identifier of the domain manager. */ DomainManagerExtId *string `json:"domainManagerExtId"` /* One of the locations must be specified as the primary location. All the other locations must be connected to the primary location. */ IsPrimary *bool `json:"isPrimary,omitempty"` /* This is a unique user defined label of the replication location. It is used to identify the location in the replication configurations. */ Label *string `json:"label"` /* */ ReplicationSubLocationItemDiscriminator_ *string `json:"$replicationSubLocationItemDiscriminator,omitempty"` /* Specifies the replication sublocations where recovery points can be created or replicated. */ ReplicationSubLocation *OneOfReplicationLocationReplicationSubLocation `json:"replicationSubLocation,omitempty"` } func (p *ReplicationLocation) MarshalJSON() ([]byte, error) { type ReplicationLocationProxy ReplicationLocation // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *ReplicationLocationProxy DomainManagerExtId *string `json:"domainManagerExtId,omitempty"` Label *string `json:"label,omitempty"` }{ ReplicationLocationProxy: (*ReplicationLocationProxy)(p), DomainManagerExtId: p.DomainManagerExtId, Label: p.Label, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *ReplicationLocation) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias ReplicationLocation known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewReplicationLocation() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DomainManagerExtId != nil { p.DomainManagerExtId = known.DomainManagerExtId } if known.IsPrimary != nil { p.IsPrimary = known.IsPrimary } if known.Label != nil { p.Label = known.Label } if known.ReplicationSubLocationItemDiscriminator_ != nil { p.ReplicationSubLocationItemDiscriminator_ = known.ReplicationSubLocationItemDiscriminator_ } if known.ReplicationSubLocation != nil { p.ReplicationSubLocation = known.ReplicationSubLocation } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "domainManagerExtId") delete(allFields, "isPrimary") delete(allFields, "label") delete(allFields, "$replicationSubLocationItemDiscriminator") delete(allFields, "replicationSubLocation") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewReplicationLocation() *ReplicationLocation { p := new(ReplicationLocation) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.ReplicationLocation" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *ReplicationLocation) GetReplicationSubLocation() interface{} { if nil == p.ReplicationSubLocation { return nil } return p.ReplicationSubLocation.GetValue() } func (p *ReplicationLocation) SetReplicationSubLocation(v interface{}) error { if nil == p.ReplicationSubLocation { p.ReplicationSubLocation = NewOneOfReplicationLocationReplicationSubLocation() } e := p.ReplicationSubLocation.SetValue(v) if nil == e { if nil == p.ReplicationSubLocationItemDiscriminator_ { p.ReplicationSubLocationItemDiscriminator_ = new(string) } *p.ReplicationSubLocationItemDiscriminator_ = *p.ReplicationSubLocation.Discriminator } return e } /* Schedule for protection. The schedule specifies the recovery point objective and the retention policy for the participating locations. */ type Schedule struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` DayOfWeek *DayOfWeek `json:"dayOfWeek,omitempty"` /* Indicates whether replication is paused for all VMs and volume groups associated with the remote replication location. This field is ignored in create requests (treated as a no-op) and can only be used in update requests to pause or resume scheduled replication. Only 0 RPO schedules support this field. */ IsReplicationPaused *bool `json:"isReplicationPaused,omitempty"` /* Indicates the duration (in seconds) that the latest recovery point is retained past its expiry time if the entity is unprotected, deleted, or migrated to another location. If not specified, the latest recovery point will be retained for a minimum duration of 30 days. The value must be set to 0 if the user does not want to retain the latest recovery point past its expiry time. */ LatestRecoveryPointRetentionSeconds *int `json:"latestRecoveryPointRetentionSeconds,omitempty"` /* The Recovery point objective of the schedule in seconds and specified in multiple of 60 seconds. Only following RPO values can be provided for rollup retention type:
Minute(s): 1, 2, 3, 4, 5, 6, 10, 12, 15
Hour(s): 1, 2, 3, 4, 6, 8, 12
Day(s): 1
Week(s): 1, 2 */ RecoveryPointObjectiveTimeSeconds *int `json:"recoveryPointObjectiveTimeSeconds"` RecoveryPointType *import7.RecoveryPointType `json:"recoveryPointType,omitempty"` /* */ RetentionItemDiscriminator_ *string `json:"$retentionItemDiscriminator,omitempty"` /* Specifies the retention policy for the recovery point schedule. */ Retention *OneOfScheduleRetention `json:"retention,omitempty"` /* The system-generated schedule ID for the replication configuration. It must not be provided in the create request. In update requests, it can be included to identify and retain the same schedule. */ ScheduleExtId *string `json:"scheduleExtId,omitempty"` /* Represents the protection start time for the new entities added to the policy after the policy is created in h:m format. The values must be between 00h:00m and 23h:59m and in UTC timezone. It specifies the time when the first snapshot is taken and replicated for any entity added to the policy. If this is not specified, the snapshot is taken immediately and replicated for any new entity added to the policy. */ StartTime *string `json:"startTime,omitempty"` /* Auto suspend timeout if there is a connection failure between locations for synchronous replication. If this value is not set, then the policy will not be suspended. */ SyncReplicationAutoSuspendTimeoutSeconds *int `json:"syncReplicationAutoSuspendTimeoutSeconds,omitempty"` } func (p *Schedule) MarshalJSON() ([]byte, error) { type ScheduleProxy Schedule // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *ScheduleProxy RecoveryPointObjectiveTimeSeconds *int `json:"recoveryPointObjectiveTimeSeconds,omitempty"` }{ ScheduleProxy: (*ScheduleProxy)(p), RecoveryPointObjectiveTimeSeconds: p.RecoveryPointObjectiveTimeSeconds, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *Schedule) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias Schedule known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewSchedule() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DayOfWeek != nil { p.DayOfWeek = known.DayOfWeek } if known.IsReplicationPaused != nil { p.IsReplicationPaused = known.IsReplicationPaused } if known.LatestRecoveryPointRetentionSeconds != nil { p.LatestRecoveryPointRetentionSeconds = known.LatestRecoveryPointRetentionSeconds } if known.RecoveryPointObjectiveTimeSeconds != nil { p.RecoveryPointObjectiveTimeSeconds = known.RecoveryPointObjectiveTimeSeconds } if known.RecoveryPointType != nil { p.RecoveryPointType = known.RecoveryPointType } if known.RetentionItemDiscriminator_ != nil { p.RetentionItemDiscriminator_ = known.RetentionItemDiscriminator_ } if known.Retention != nil { p.Retention = known.Retention } if known.ScheduleExtId != nil { p.ScheduleExtId = known.ScheduleExtId } if known.StartTime != nil { p.StartTime = known.StartTime } if known.SyncReplicationAutoSuspendTimeoutSeconds != nil { p.SyncReplicationAutoSuspendTimeoutSeconds = known.SyncReplicationAutoSuspendTimeoutSeconds } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "dayOfWeek") delete(allFields, "isReplicationPaused") delete(allFields, "latestRecoveryPointRetentionSeconds") delete(allFields, "recoveryPointObjectiveTimeSeconds") delete(allFields, "recoveryPointType") delete(allFields, "$retentionItemDiscriminator") delete(allFields, "retention") delete(allFields, "scheduleExtId") delete(allFields, "startTime") delete(allFields, "syncReplicationAutoSuspendTimeoutSeconds") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewSchedule() *Schedule { p := new(Schedule) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.Schedule" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *Schedule) GetRetention() interface{} { if nil == p.Retention { return nil } return p.Retention.GetValue() } func (p *Schedule) SetRetention(v interface{}) error { if nil == p.Retention { p.Retention = NewOneOfScheduleRetention() } e := p.Retention.SetValue(v) if nil == e { if nil == p.RetentionItemDiscriminator_ { p.RetentionItemDiscriminator_ = new(string) } *p.RetentionItemDiscriminator_ = *p.Retention.Discriminator } return e } /* Snapshot interval period. */ type SnapshotIntervalType int const ( SNAPSHOTINTERVALTYPE_UNKNOWN SnapshotIntervalType = 0 SNAPSHOTINTERVALTYPE_REDACTED SnapshotIntervalType = 1 SNAPSHOTINTERVALTYPE_HOURLY SnapshotIntervalType = 2 SNAPSHOTINTERVALTYPE_DAILY SnapshotIntervalType = 3 SNAPSHOTINTERVALTYPE_WEEKLY SnapshotIntervalType = 4 SNAPSHOTINTERVALTYPE_MONTHLY SnapshotIntervalType = 5 SNAPSHOTINTERVALTYPE_YEARLY SnapshotIntervalType = 6 ) // Returns the name of the enum given an ordinal number // // Deprecated: Please use GetName instead of name func (e *SnapshotIntervalType) name(index int) string { names := [...]string{ "$UNKNOWN", "$REDACTED", "HOURLY", "DAILY", "WEEKLY", "MONTHLY", "YEARLY", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the name of the enum func (e SnapshotIntervalType) GetName() string { index := int(e) names := [...]string{ "$UNKNOWN", "$REDACTED", "HOURLY", "DAILY", "WEEKLY", "MONTHLY", "YEARLY", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the enum type given a string value func (e *SnapshotIntervalType) index(name string) SnapshotIntervalType { names := [...]string{ "$UNKNOWN", "$REDACTED", "HOURLY", "DAILY", "WEEKLY", "MONTHLY", "YEARLY", } for idx := range names { if names[idx] == name { return SnapshotIntervalType(idx) } } return SNAPSHOTINTERVALTYPE_UNKNOWN } func (e *SnapshotIntervalType) UnmarshalJSON(b []byte) error { var enumStr string if err := json.Unmarshal(b, &enumStr); err != nil { return errors.New(fmt.Sprintf("Unable to unmarshal for SnapshotIntervalType:%s", err)) } *e = e.index(enumStr) return nil } func (e *SnapshotIntervalType) MarshalJSON() ([]byte, error) { b := bytes.NewBufferString(`"`) b.WriteString(e.name(int(*e))) b.WriteString(`"`) return b.Bytes(), nil } func (e SnapshotIntervalType) Ref() *SnapshotIntervalType { return &e } /* Information about the action to be executed at the end of a stage. */ type StageAction struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ ConfigItemDiscriminator_ *string `json:"$configItemDiscriminator,omitempty"` /* The settings required to control the stage action. For example, stage action of type DELAY requires the number of seconds to delay after a stage completes. */ Config *OneOfStageActionConfig `json:"config"` } func (p *StageAction) MarshalJSON() ([]byte, error) { type StageActionProxy StageAction // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *StageActionProxy Config *OneOfStageActionConfig `json:"config,omitempty"` }{ StageActionProxy: (*StageActionProxy)(p), Config: p.Config, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *StageAction) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias StageAction known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewStageAction() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.ConfigItemDiscriminator_ != nil { p.ConfigItemDiscriminator_ = known.ConfigItemDiscriminator_ } if known.Config != nil { p.Config = known.Config } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$configItemDiscriminator") delete(allFields, "config") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewStageAction() *StageAction { p := new(StageAction) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.StageAction" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *StageAction) GetConfig() interface{} { if nil == p.Config { return nil } return p.Config.GetValue() } func (p *StageAction) SetConfig(v interface{}) error { if nil == p.Config { p.Config = NewOneOfStageActionConfig() } e := p.Config.SetValue(v) if nil == e { if nil == p.ConfigItemDiscriminator_ { p.ConfigItemDiscriminator_ = new(string) } *p.ConfigItemDiscriminator_ = *p.Config.Discriminator } return e } /* A model that represents a Storage Policy resource. */ type StoragePolicy struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* List of external identifiers of Categories included or to be included in the Storage Policy. */ CategoryExtIds []string `json:"categoryExtIds,omitempty"` CompressionSpec *CompressionSpec `json:"compressionSpec,omitempty"` EncryptionSpec *EncryptionSpec `json:"encryptionSpec,omitempty"` /* A globally unique identifier of an instance that is suitable for external consumption. */ ExtId *string `json:"extId,omitempty"` FaultToleranceSpec *FaultToleranceSpec `json:"faultToleranceSpec,omitempty"` /* A HATEOAS style link for the response. Each link contains a user-friendly name identifying the link and an address for retrieving the particular resource. */ Links []import1.ApiLink `json:"links,omitempty"` /* Indicates the Storage Policy name. Note that the name of the Storage Policy should be unique. */ Name *string `json:"name,omitempty"` /* Indicates the UUID of the owner of the Storage Policy. */ OwnerUuid *string `json:"ownerUuid,omitempty"` PolicyType *PolicyType `json:"policyType,omitempty"` QosSpec *QosSpec `json:"qosSpec,omitempty"` /* A globally unique identifier that represents the tenant that owns this entity. The system automatically assigns it, and it and is immutable from an API consumer perspective (some use cases may cause this ID to change - For instance, a use case may require the transfer of ownership of the entity, but these cases are handled automatically on the server). */ TenantId *string `json:"tenantId,omitempty"` } func (p *StoragePolicy) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias StoragePolicy // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *StoragePolicy) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias StoragePolicy known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewStoragePolicy() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.CategoryExtIds != nil { p.CategoryExtIds = known.CategoryExtIds } if known.CompressionSpec != nil { p.CompressionSpec = known.CompressionSpec } if known.EncryptionSpec != nil { p.EncryptionSpec = known.EncryptionSpec } if known.ExtId != nil { p.ExtId = known.ExtId } if known.FaultToleranceSpec != nil { p.FaultToleranceSpec = known.FaultToleranceSpec } if known.Links != nil { p.Links = known.Links } if known.Name != nil { p.Name = known.Name } if known.OwnerUuid != nil { p.OwnerUuid = known.OwnerUuid } if known.PolicyType != nil { p.PolicyType = known.PolicyType } if known.QosSpec != nil { p.QosSpec = known.QosSpec } if known.TenantId != nil { p.TenantId = known.TenantId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "categoryExtIds") delete(allFields, "compressionSpec") delete(allFields, "encryptionSpec") delete(allFields, "extId") delete(allFields, "faultToleranceSpec") delete(allFields, "links") delete(allFields, "name") delete(allFields, "ownerUuid") delete(allFields, "policyType") delete(allFields, "qosSpec") delete(allFields, "tenantId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewStoragePolicy() *StoragePolicy { p := new(StoragePolicy) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.StoragePolicy" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* REST response for all response codes in API path /datapolicies/v4.3/config/entity-sync-policies/{extId}/$actions/sync-entity Post operation */ type SyncEntitySyncPolicyApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfSyncEntitySyncPolicyApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *SyncEntitySyncPolicyApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias SyncEntitySyncPolicyApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *SyncEntitySyncPolicyApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias SyncEntitySyncPolicyApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewSyncEntitySyncPolicyApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewSyncEntitySyncPolicyApiResponse() *SyncEntitySyncPolicyApiResponse { p := new(SyncEntitySyncPolicyApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.SyncEntitySyncPolicyApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *SyncEntitySyncPolicyApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *SyncEntitySyncPolicyApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfSyncEntitySyncPolicyApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* entityType string (datapolicies.v4.0.a1.config.SyncedEntityType) The type of entity. The values are as follows: */ type SyncedEntityType int const ( SYNCEDENTITYTYPE_UNKNOWN SyncedEntityType = 0 SYNCEDENTITYTYPE_REDACTED SyncedEntityType = 1 SYNCEDENTITYTYPE_SECURITY_POLICY SyncedEntityType = 2 SYNCEDENTITYTYPE_STORAGE_POLICY SyncedEntityType = 3 SYNCEDENTITYTYPE_CATEGORY SyncedEntityType = 4 SYNCEDENTITYTYPE_PROTECTION_POLICY SyncedEntityType = 5 SYNCEDENTITYTYPE_RECOVERY_PLAN SyncedEntityType = 6 SYNCEDENTITYTYPE_ADDRESS_GROUP SyncedEntityType = 7 SYNCEDENTITYTYPE_SERVICE_GROUP SyncedEntityType = 8 SYNCEDENTITYTYPE_SUBNET SyncedEntityType = 9 SYNCEDENTITYTYPE_ENTITY_GROUP SyncedEntityType = 10 ) // Returns the name of the enum given an ordinal number // // Deprecated: Please use GetName instead of name func (e *SyncedEntityType) name(index int) string { names := [...]string{ "$UNKNOWN", "$REDACTED", "SECURITY_POLICY", "STORAGE_POLICY", "CATEGORY", "PROTECTION_POLICY", "RECOVERY_PLAN", "ADDRESS_GROUP", "SERVICE_GROUP", "SUBNET", "ENTITY_GROUP", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the name of the enum func (e SyncedEntityType) GetName() string { index := int(e) names := [...]string{ "$UNKNOWN", "$REDACTED", "SECURITY_POLICY", "STORAGE_POLICY", "CATEGORY", "PROTECTION_POLICY", "RECOVERY_PLAN", "ADDRESS_GROUP", "SERVICE_GROUP", "SUBNET", "ENTITY_GROUP", } if index < 0 || index >= len(names) { return "$UNKNOWN" } return names[index] } // Returns the enum type given a string value func (e *SyncedEntityType) index(name string) SyncedEntityType { names := [...]string{ "$UNKNOWN", "$REDACTED", "SECURITY_POLICY", "STORAGE_POLICY", "CATEGORY", "PROTECTION_POLICY", "RECOVERY_PLAN", "ADDRESS_GROUP", "SERVICE_GROUP", "SUBNET", "ENTITY_GROUP", } for idx := range names { if names[idx] == name { return SyncedEntityType(idx) } } return SYNCEDENTITYTYPE_UNKNOWN } func (e *SyncedEntityType) UnmarshalJSON(b []byte) error { var enumStr string if err := json.Unmarshal(b, &enumStr); err != nil { return errors.New(fmt.Sprintf("Unable to unmarshal for SyncedEntityType:%s", err)) } *e = e.index(enumStr) return nil } func (e *SyncedEntityType) MarshalJSON() ([]byte, error) { b := bytes.NewBufferString(`"`) b.WriteString(e.name(int(*e))) b.WriteString(`"`) return b.Bytes(), nil } func (e SyncedEntityType) Ref() *SyncedEntityType { return &e } /* REST response for all response codes in API path /datapolicies/v4.3/config/protection-policies/{protectionPolicyExtId}/consistency-rules/{extId} Put operation */ type UpdateConsistencyRuleApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfUpdateConsistencyRuleApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *UpdateConsistencyRuleApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias UpdateConsistencyRuleApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *UpdateConsistencyRuleApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias UpdateConsistencyRuleApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewUpdateConsistencyRuleApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewUpdateConsistencyRuleApiResponse() *UpdateConsistencyRuleApiResponse { p := new(UpdateConsistencyRuleApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.UpdateConsistencyRuleApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *UpdateConsistencyRuleApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *UpdateConsistencyRuleApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfUpdateConsistencyRuleApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/data-services-ip-mappings/{extId} Put operation */ type UpdateDataServicesIpMappingApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfUpdateDataServicesIpMappingApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *UpdateDataServicesIpMappingApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias UpdateDataServicesIpMappingApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *UpdateDataServicesIpMappingApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias UpdateDataServicesIpMappingApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewUpdateDataServicesIpMappingApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewUpdateDataServicesIpMappingApiResponse() *UpdateDataServicesIpMappingApiResponse { p := new(UpdateDataServicesIpMappingApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.UpdateDataServicesIpMappingApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *UpdateDataServicesIpMappingApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *UpdateDataServicesIpMappingApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfUpdateDataServicesIpMappingApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/network-mappings/{extId} Put operation */ type UpdateNetworkMappingApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfUpdateNetworkMappingApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *UpdateNetworkMappingApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias UpdateNetworkMappingApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *UpdateNetworkMappingApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias UpdateNetworkMappingApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewUpdateNetworkMappingApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewUpdateNetworkMappingApiResponse() *UpdateNetworkMappingApiResponse { p := new(UpdateNetworkMappingApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.UpdateNetworkMappingApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *UpdateNetworkMappingApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *UpdateNetworkMappingApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfUpdateNetworkMappingApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/protection-policies/{extId} Put operation */ type UpdateProtectionPolicyApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfUpdateProtectionPolicyApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *UpdateProtectionPolicyApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias UpdateProtectionPolicyApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *UpdateProtectionPolicyApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias UpdateProtectionPolicyApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewUpdateProtectionPolicyApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewUpdateProtectionPolicyApiResponse() *UpdateProtectionPolicyApiResponse { p := new(UpdateProtectionPolicyApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.UpdateProtectionPolicyApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *UpdateProtectionPolicyApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *UpdateProtectionPolicyApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfUpdateProtectionPolicyApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{extId} Put operation */ type UpdateRecoveryPlanApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfUpdateRecoveryPlanApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *UpdateRecoveryPlanApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias UpdateRecoveryPlanApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *UpdateRecoveryPlanApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias UpdateRecoveryPlanApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewUpdateRecoveryPlanApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewUpdateRecoveryPlanApiResponse() *UpdateRecoveryPlanApiResponse { p := new(UpdateRecoveryPlanApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.UpdateRecoveryPlanApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *UpdateRecoveryPlanApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *UpdateRecoveryPlanApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfUpdateRecoveryPlanApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/recovery-settings/{extId} Put operation */ type UpdateRecoverySettingApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfUpdateRecoverySettingApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *UpdateRecoverySettingApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias UpdateRecoverySettingApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *UpdateRecoverySettingApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias UpdateRecoverySettingApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewUpdateRecoverySettingApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewUpdateRecoverySettingApiResponse() *UpdateRecoverySettingApiResponse { p := new(UpdateRecoverySettingApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.UpdateRecoverySettingApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *UpdateRecoverySettingApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *UpdateRecoverySettingApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfUpdateRecoverySettingApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/recovery-plans/{recoveryPlanExtId}/stages/{extId} Put operation */ type UpdateRecoveryStageApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfUpdateRecoveryStageApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *UpdateRecoveryStageApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias UpdateRecoveryStageApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *UpdateRecoveryStageApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias UpdateRecoveryStageApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewUpdateRecoveryStageApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewUpdateRecoveryStageApiResponse() *UpdateRecoveryStageApiResponse { p := new(UpdateRecoveryStageApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.UpdateRecoveryStageApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *UpdateRecoveryStageApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *UpdateRecoveryStageApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfUpdateRecoveryStageApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* REST response for all response codes in API path /datapolicies/v4.3/config/storage-policies/{extId} Put operation */ type UpdateStoragePolicyApiResponse struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* */ DataItemDiscriminator_ *string `json:"$dataItemDiscriminator,omitempty"` Data *OneOfUpdateStoragePolicyApiResponseData `json:"data,omitempty"` Metadata *import1.ApiResponseMetadata `json:"metadata,omitempty"` } func (p *UpdateStoragePolicyApiResponse) MarshalJSON() ([]byte, error) { // Create Alias to avoid infinite recursion type Alias UpdateStoragePolicyApiResponse // Step 1: Marshal the known fields known, err := json.Marshal(Alias(*p)) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *UpdateStoragePolicyApiResponse) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias UpdateStoragePolicyApiResponse known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewUpdateStoragePolicyApiResponse() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.DataItemDiscriminator_ != nil { p.DataItemDiscriminator_ = known.DataItemDiscriminator_ } if known.Data != nil { p.Data = known.Data } if known.Metadata != nil { p.Metadata = known.Metadata } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "$dataItemDiscriminator") delete(allFields, "data") delete(allFields, "metadata") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewUpdateStoragePolicyApiResponse() *UpdateStoragePolicyApiResponse { p := new(UpdateStoragePolicyApiResponse) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.UpdateStoragePolicyApiResponse" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *UpdateStoragePolicyApiResponse) GetData() interface{} { if nil == p.Data { return nil } return p.Data.GetValue() } func (p *UpdateStoragePolicyApiResponse) SetData(v interface{}) error { if nil == p.Data { p.Data = NewOneOfUpdateStoragePolicyApiResponseData() } e := p.Data.SetValue(v) if nil == e { if nil == p.DataItemDiscriminator_ { p.DataItemDiscriminator_ = new(string) } *p.DataItemDiscriminator_ = *p.Data.Discriminator } return e } /* Recovery setting applicable to all VMs in the category. */ type VmCategoryRecoverySetting struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` InGuestScriptExecutionConfig *InGuestScriptExecutionConfig `json:"inGuestScriptExecutionConfig,omitempty"` PowerState *PowerState `json:"powerState,omitempty"` /* External identifier of the VM category. */ VmCategoryExtId *string `json:"vmCategoryExtId"` } func (p *VmCategoryRecoverySetting) MarshalJSON() ([]byte, error) { type VmCategoryRecoverySettingProxy VmCategoryRecoverySetting // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *VmCategoryRecoverySettingProxy VmCategoryExtId *string `json:"vmCategoryExtId,omitempty"` }{ VmCategoryRecoverySettingProxy: (*VmCategoryRecoverySettingProxy)(p), VmCategoryExtId: p.VmCategoryExtId, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *VmCategoryRecoverySetting) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias VmCategoryRecoverySetting known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewVmCategoryRecoverySetting() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.InGuestScriptExecutionConfig != nil { p.InGuestScriptExecutionConfig = known.InGuestScriptExecutionConfig } if known.PowerState != nil { p.PowerState = known.PowerState } if known.VmCategoryExtId != nil { p.VmCategoryExtId = known.VmCategoryExtId } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "inGuestScriptExecutionConfig") delete(allFields, "powerState") delete(allFields, "vmCategoryExtId") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewVmCategoryRecoverySetting() *VmCategoryRecoverySetting { p := new(VmCategoryRecoverySetting) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.VmCategoryRecoverySetting" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Recovery configuration for VMs. */ type VmRecoverySetting struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* List of floating IP address associations. primaryFloatingIp and recoveryFloatingIp are the configurations for assigning floating IP to a VM after a failover or failback action on recovery plan. primaryTestFloatingIp and recoveryTestFloatingIp are the configurations for assigning floating IP to a VM after a failover or failback action on test network on recovery plan. */ FloatingIpAssociations []FloatingIpAssociation `json:"floatingIpAssociations,omitempty"` InGuestScriptExecutionConfig *InGuestScriptExecutionConfig `json:"inGuestScriptExecutionConfig,omitempty"` /* List of static IP address mappings for the VM. In IP mappings, the prefixLength for an exact IP address should always be 32. IPv6 IP mapping and floating IP mapping is not supported. */ IpMappings []IpMapping `json:"ipMappings,omitempty"` PowerState *PowerState `json:"powerState,omitempty"` Vm *EntityReference `json:"vm"` /* List of Volume Groups to be attached to the Virtual Machine (VM).
attachmentType(s) supported are `EXTERNAL`.
protocol(s) supported are `ISCSI` and `None`.
clientFeatures must be specified for mutual CHAP based iSCSI authentications. */ VolumeGroupAttachments []VolumeGroupAttachment `json:"volumeGroupAttachments,omitempty"` } func (p *VmRecoverySetting) MarshalJSON() ([]byte, error) { type VmRecoverySettingProxy VmRecoverySetting // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *VmRecoverySettingProxy Vm *EntityReference `json:"vm,omitempty"` }{ VmRecoverySettingProxy: (*VmRecoverySettingProxy)(p), Vm: p.Vm, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *VmRecoverySetting) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias VmRecoverySetting known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewVmRecoverySetting() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.FloatingIpAssociations != nil { p.FloatingIpAssociations = known.FloatingIpAssociations } if known.InGuestScriptExecutionConfig != nil { p.InGuestScriptExecutionConfig = known.InGuestScriptExecutionConfig } if known.IpMappings != nil { p.IpMappings = known.IpMappings } if known.PowerState != nil { p.PowerState = known.PowerState } if known.Vm != nil { p.Vm = known.Vm } if known.VolumeGroupAttachments != nil { p.VolumeGroupAttachments = known.VolumeGroupAttachments } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "floatingIpAssociations") delete(allFields, "inGuestScriptExecutionConfig") delete(allFields, "ipMappings") delete(allFields, "powerState") delete(allFields, "vm") delete(allFields, "volumeGroupAttachments") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewVmRecoverySetting() *VmRecoverySetting { p := new(VmRecoverySetting) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.VmRecoverySetting" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Volume Group attachment. */ type VolumeGroupAttachment struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` AttachmentType *import6.AttachmentType `json:"attachmentType"` /* */ ClientFeaturesItemDiscriminator_ *string `json:"$clientFeaturesItemDiscriminator,omitempty"` /* Attachment protocol specific settings. This field is only applicable when attachmentType is `EXTERNAL_ATTACH`. Client secret must be specified for mutual `CHAP` authentications. */ ClientFeatures *OneOfVolumeGroupAttachmentClientFeatures `json:"clientFeatures,omitempty"` Protocol *import6.Protocol `json:"protocol,omitempty"` VolumeGroup *EntityReference `json:"volumeGroup"` } func (p *VolumeGroupAttachment) MarshalJSON() ([]byte, error) { type VolumeGroupAttachmentProxy VolumeGroupAttachment // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *VolumeGroupAttachmentProxy AttachmentType *import6.AttachmentType `json:"attachmentType,omitempty"` VolumeGroup *EntityReference `json:"volumeGroup,omitempty"` }{ VolumeGroupAttachmentProxy: (*VolumeGroupAttachmentProxy)(p), AttachmentType: p.AttachmentType, VolumeGroup: p.VolumeGroup, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *VolumeGroupAttachment) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias VolumeGroupAttachment known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewVolumeGroupAttachment() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.AttachmentType != nil { p.AttachmentType = known.AttachmentType } if known.ClientFeaturesItemDiscriminator_ != nil { p.ClientFeaturesItemDiscriminator_ = known.ClientFeaturesItemDiscriminator_ } if known.ClientFeatures != nil { p.ClientFeatures = known.ClientFeatures } if known.Protocol != nil { p.Protocol = known.Protocol } if known.VolumeGroup != nil { p.VolumeGroup = known.VolumeGroup } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "attachmentType") delete(allFields, "$clientFeaturesItemDiscriminator") delete(allFields, "clientFeatures") delete(allFields, "protocol") delete(allFields, "volumeGroup") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewVolumeGroupAttachment() *VolumeGroupAttachment { p := new(VolumeGroupAttachment) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.VolumeGroupAttachment" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } func (p *VolumeGroupAttachment) GetClientFeatures() interface{} { if nil == p.ClientFeatures { return nil } return p.ClientFeatures.GetValue() } func (p *VolumeGroupAttachment) SetClientFeatures(v interface{}) error { if nil == p.ClientFeatures { p.ClientFeatures = NewOneOfVolumeGroupAttachmentClientFeatures() } e := p.ClientFeatures.SetValue(v) if nil == e { if nil == p.ClientFeaturesItemDiscriminator_ { p.ClientFeaturesItemDiscriminator_ = new(string) } *p.ClientFeaturesItemDiscriminator_ = *p.ClientFeatures.Discriminator } return e } /* Recovery configuration for Volume Groups. */ type VolumeGroupRecoverySetting struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` IscsiTargetFeatures *IscsiFeatures `json:"iscsiTargetFeatures"` VolumeGroup *EntityReference `json:"volumeGroup"` } func (p *VolumeGroupRecoverySetting) MarshalJSON() ([]byte, error) { type VolumeGroupRecoverySettingProxy VolumeGroupRecoverySetting // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *VolumeGroupRecoverySettingProxy IscsiTargetFeatures *IscsiFeatures `json:"iscsiTargetFeatures,omitempty"` VolumeGroup *EntityReference `json:"volumeGroup,omitempty"` }{ VolumeGroupRecoverySettingProxy: (*VolumeGroupRecoverySettingProxy)(p), IscsiTargetFeatures: p.IscsiTargetFeatures, VolumeGroup: p.VolumeGroup, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *VolumeGroupRecoverySetting) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias VolumeGroupRecoverySetting known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewVolumeGroupRecoverySetting() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.IscsiTargetFeatures != nil { p.IscsiTargetFeatures = known.IscsiTargetFeatures } if known.VolumeGroup != nil { p.VolumeGroup = known.VolumeGroup } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "iscsiTargetFeatures") delete(allFields, "volumeGroup") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewVolumeGroupRecoverySetting() *VolumeGroupRecoverySetting { p := new(VolumeGroupRecoverySetting) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.VolumeGroupRecoverySetting" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } /* Witness location and failover configuration. */ type WitnessConfiguration struct { ObjectType_ *string `json:"$objectType,omitempty"` Reserved_ map[string]interface{} `json:"$reserved,omitempty"` UnknownFields_ map[string]interface{} `json:"$unknownFields,omitempty"` /* External identifier of the witness service. */ ExtId *string `json:"extId"` /* Maximum time in seconds that the witness must wait before initiating an unplanned failover or pausing synchronous replication in the event of a primary or secondary location failure. */ TimeoutSecs *int `json:"timeoutSecs"` } func (p *WitnessConfiguration) MarshalJSON() ([]byte, error) { type WitnessConfigurationProxy WitnessConfiguration // Step 1: Marshal known fields via proxy to enforce required fields baseStruct := struct { *WitnessConfigurationProxy ExtId *string `json:"extId,omitempty"` TimeoutSecs *int `json:"timeoutSecs,omitempty"` }{ WitnessConfigurationProxy: (*WitnessConfigurationProxy)(p), ExtId: p.ExtId, TimeoutSecs: p.TimeoutSecs, } known, err := json.Marshal(baseStruct) if err != nil { return nil, err } // Step 2: Convert known to map for merging var knownMap map[string]interface{} if err := json.Unmarshal(known, &knownMap); err != nil { return nil, err } delete(knownMap, "$unknownFields") // Step 3: Merge unknown fields for k, v := range p.UnknownFields_ { knownMap[k] = v } // Step 4: Marshal final merged map return json.Marshal(knownMap) } func (p *WitnessConfiguration) UnmarshalJSON(b []byte) error { // Step 1: Unmarshal into a generic map to capture all fields var allFields map[string]interface{} if err := json.Unmarshal(b, &allFields); err != nil { return err } // Step 2: Unmarshal into a temporary struct with known fields type Alias WitnessConfiguration known := &Alias{} if err := json.Unmarshal(b, known); err != nil { return err } // Step 3: Assign known fields *p = *NewWitnessConfiguration() if known.ObjectType_ != nil { p.ObjectType_ = known.ObjectType_ } if known.Reserved_ != nil { p.Reserved_ = known.Reserved_ } if known.UnknownFields_ != nil { p.UnknownFields_ = known.UnknownFields_ } if known.ExtId != nil { p.ExtId = known.ExtId } if known.TimeoutSecs != nil { p.TimeoutSecs = known.TimeoutSecs } // Step 4: Remove known JSON fields from allFields map delete(allFields, "$objectType") delete(allFields, "$reserved") delete(allFields, "$unknownFields") delete(allFields, "extId") delete(allFields, "timeoutSecs") // Step 5: Assign remaining fields to UnknownFields_ for key, value := range allFields { p.UnknownFields_[key] = value } return nil } func NewWitnessConfiguration() *WitnessConfiguration { p := new(WitnessConfiguration) p.ObjectType_ = new(string) *p.ObjectType_ = "datapolicies.v4.config.WitnessConfiguration" p.Reserved_ = map[string]interface{}{"$fv": "v4.r3"} p.UnknownFields_ = map[string]interface{}{} return p } type OneOfListDataServicesIpMappingsApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 []DataServicesIpMapping `json:"-"` oneOfType401 []DataServicesIpMappingProjection `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfListDataServicesIpMappingsApiResponseData() *OneOfListDataServicesIpMappingsApiResponseData { p := new(OneOfListDataServicesIpMappingsApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfListDataServicesIpMappingsApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfListDataServicesIpMappingsApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case []DataServicesIpMapping: p.oneOfType2001 = v.([]DataServicesIpMapping) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" case []DataServicesIpMappingProjection: p.oneOfType401 = v.([]DataServicesIpMappingProjection) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfListDataServicesIpMappingsApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if "List" == *p.Discriminator { return p.oneOfType2001 } if "List" == *p.Discriminator { return p.oneOfType401 } return nil } func (p *OneOfListDataServicesIpMappingsApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new([]DataServicesIpMapping) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType2001 == nil || len(*vOneOfType2001) == 0 || ((*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.DataServicesIpMapping" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType401 := new([]DataServicesIpMappingProjection) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType401) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType401 == nil || len(*vOneOfType401) == 0 || ((*vOneOfType401)[0].ObjectType_ != nil && "datapolicies.v4.config.DataServicesIpMappingProjection" == *((*vOneOfType401)[0].ObjectType_)) { p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new([]DataServicesIpMapping) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if len(*vOneOfType2001) == 0 || (vOneOfType2001 != nil && (*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.DataServicesIpMapping" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } vOneOfType401 := new([]DataServicesIpMappingProjection) if err := json.Unmarshal(b, vOneOfType401); err == nil { if len(*vOneOfType401) == 0 || (vOneOfType401 != nil && (*vOneOfType401)[0].ObjectType_ != nil && "datapolicies.v4.config.DataServicesIpMappingProjection" == *((*vOneOfType401)[0].ObjectType_)) { p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfListDataServicesIpMappingsApiResponseData")) } func (p *OneOfListDataServicesIpMappingsApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType2001) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType401) } return nil, errors.New("No value to marshal for OneOfListDataServicesIpMappingsApiResponseData") } type OneOfListConsistencyRulesApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType2001 []ConsistencyRule `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType401 []ConsistencyRuleProjection `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfListConsistencyRulesApiResponseData() *OneOfListConsistencyRulesApiResponseData { p := new(OneOfListConsistencyRulesApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfListConsistencyRulesApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfListConsistencyRulesApiResponseData is nil")) } switch v.(type) { case []ConsistencyRule: p.oneOfType2001 = v.([]ConsistencyRule) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case []ConsistencyRuleProjection: p.oneOfType401 = v.([]ConsistencyRuleProjection) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfListConsistencyRulesApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if "List" == *p.Discriminator { return p.oneOfType2001 } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if "List" == *p.Discriminator { return p.oneOfType401 } return nil } func (p *OneOfListConsistencyRulesApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new([]ConsistencyRule) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType2001 == nil || len(*vOneOfType2001) == 0 || ((*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.ConsistencyRule" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType401 := new([]ConsistencyRuleProjection) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType401) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType401 == nil || len(*vOneOfType401) == 0 || ((*vOneOfType401)[0].ObjectType_ != nil && "datapolicies.v4.config.ConsistencyRuleProjection" == *((*vOneOfType401)[0].ObjectType_)) { p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType2001 := new([]ConsistencyRule) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if len(*vOneOfType2001) == 0 || (vOneOfType2001 != nil && (*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.ConsistencyRule" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType401 := new([]ConsistencyRuleProjection) if err := json.Unmarshal(b, vOneOfType401); err == nil { if len(*vOneOfType401) == 0 || (vOneOfType401 != nil && (*vOneOfType401)[0].ObjectType_ != nil && "datapolicies.v4.config.ConsistencyRuleProjection" == *((*vOneOfType401)[0].ObjectType_)) { p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfListConsistencyRulesApiResponseData")) } func (p *OneOfListConsistencyRulesApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType2001) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType401) } return nil, errors.New("No value to marshal for OneOfListConsistencyRulesApiResponseData") } type OneOfUpdateProtectionPolicyApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfUpdateProtectionPolicyApiResponseData() *OneOfUpdateProtectionPolicyApiResponseData { p := new(OneOfUpdateProtectionPolicyApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfUpdateProtectionPolicyApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfUpdateProtectionPolicyApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfUpdateProtectionPolicyApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfUpdateProtectionPolicyApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfUpdateProtectionPolicyApiResponseData")) } func (p *OneOfUpdateProtectionPolicyApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfUpdateProtectionPolicyApiResponseData") } type OneOfUpdateNetworkMappingApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfUpdateNetworkMappingApiResponseData() *OneOfUpdateNetworkMappingApiResponseData { p := new(OneOfUpdateNetworkMappingApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfUpdateNetworkMappingApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfUpdateNetworkMappingApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfUpdateNetworkMappingApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfUpdateNetworkMappingApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfUpdateNetworkMappingApiResponseData")) } func (p *OneOfUpdateNetworkMappingApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfUpdateNetworkMappingApiResponseData") } type OneOfEntitySyncPolicyAggregateResult struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType2003 *int `json:"-"` oneOfType2005 *float64 `json:"-"` oneOfType2006 []EntitySyncPolicyTimeValuePair `json:"-"` oneOfType2004 *int64 `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfEntitySyncPolicyAggregateResult() *OneOfEntitySyncPolicyAggregateResult { p := new(OneOfEntitySyncPolicyAggregateResult) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfEntitySyncPolicyAggregateResult) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfEntitySyncPolicyAggregateResult is nil")) } switch v.(type) { case int: if nil == p.oneOfType2003 { p.oneOfType2003 = new(int) } *p.oneOfType2003 = v.(int) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Integer" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Integer" case float64: if nil == p.oneOfType2005 { p.oneOfType2005 = new(float64) } *p.oneOfType2005 = v.(float64) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Double" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Double" case []EntitySyncPolicyTimeValuePair: p.oneOfType2006 = v.([]EntitySyncPolicyTimeValuePair) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" case int64: if nil == p.oneOfType2004 { p.oneOfType2004 = new(int64) } *p.oneOfType2004 = v.(int64) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Long" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Long" default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfEntitySyncPolicyAggregateResult) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if "Integer" == *p.Discriminator { return *p.oneOfType2003 } if "Double" == *p.Discriminator { return *p.oneOfType2005 } if "List" == *p.Discriminator { return p.oneOfType2006 } if "Long" == *p.Discriminator { return *p.oneOfType2004 } return nil } func (p *OneOfEntitySyncPolicyAggregateResult) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["Integer"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2003 := new(int) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2003) if unmarshalErr == nil { if nil == p.oneOfType2003 { p.oneOfType2003 = new(int) } *p.oneOfType2003 = *vOneOfType2003 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Integer" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Integer" return nil } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["Double"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2005 := new(float64) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2005) if unmarshalErr == nil { if nil == p.oneOfType2005 { p.oneOfType2005 = new(float64) } *p.oneOfType2005 = *vOneOfType2005 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Double" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Double" return nil } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2006 := new([]EntitySyncPolicyTimeValuePair) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2006) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType2006 == nil || len(*vOneOfType2006) == 0 || ((*vOneOfType2006)[0].ObjectType_ != nil && "datapolicies.v4.config.EntitySyncPolicyTimeValuePair" == *((*vOneOfType2006)[0].ObjectType_)) { p.oneOfType2006 = *vOneOfType2006 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["Long"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2004 := new(int64) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2004) if unmarshalErr == nil { if nil == p.oneOfType2004 { p.oneOfType2004 = new(int64) } *p.oneOfType2004 = *vOneOfType2004 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Long" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Long" return nil } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType2003 := new(int) if err := json.Unmarshal(b, vOneOfType2003); err == nil { if nil == p.oneOfType2003 { p.oneOfType2003 = new(int) } *p.oneOfType2003 = *vOneOfType2003 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Integer" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Integer" return nil } vOneOfType2005 := new(float64) if err := json.Unmarshal(b, vOneOfType2005); err == nil { if nil == p.oneOfType2005 { p.oneOfType2005 = new(float64) } *p.oneOfType2005 = *vOneOfType2005 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Double" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Double" return nil } vOneOfType2006 := new([]EntitySyncPolicyTimeValuePair) if err := json.Unmarshal(b, vOneOfType2006); err == nil { if len(*vOneOfType2006) == 0 || (vOneOfType2006 != nil && (*vOneOfType2006)[0].ObjectType_ != nil && "datapolicies.v4.config.EntitySyncPolicyTimeValuePair" == *((*vOneOfType2006)[0].ObjectType_)) { p.oneOfType2006 = *vOneOfType2006 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } vOneOfType2004 := new(int64) if err := json.Unmarshal(b, vOneOfType2004); err == nil { if nil == p.oneOfType2004 { p.oneOfType2004 = new(int64) } *p.oneOfType2004 = *vOneOfType2004 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Long" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Long" return nil } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfEntitySyncPolicyAggregateResult")) } func (p *OneOfEntitySyncPolicyAggregateResult) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if "Integer" == *p.Discriminator { return json.Marshal(p.oneOfType2003) } if "Double" == *p.Discriminator { return json.Marshal(p.oneOfType2005) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType2006) } if "Long" == *p.Discriminator { return json.Marshal(p.oneOfType2004) } return nil, errors.New("No value to marshal for OneOfEntitySyncPolicyAggregateResult") } type OneOfListRecoverySettingsApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType2001 []RecoverySetting `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType401 []RecoverySettingProjection `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfListRecoverySettingsApiResponseData() *OneOfListRecoverySettingsApiResponseData { p := new(OneOfListRecoverySettingsApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfListRecoverySettingsApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfListRecoverySettingsApiResponseData is nil")) } switch v.(type) { case []RecoverySetting: p.oneOfType2001 = v.([]RecoverySetting) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case []RecoverySettingProjection: p.oneOfType401 = v.([]RecoverySettingProjection) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfListRecoverySettingsApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if "List" == *p.Discriminator { return p.oneOfType2001 } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if "List" == *p.Discriminator { return p.oneOfType401 } return nil } func (p *OneOfListRecoverySettingsApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new([]RecoverySetting) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType2001 == nil || len(*vOneOfType2001) == 0 || ((*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.RecoverySetting" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType401 := new([]RecoverySettingProjection) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType401) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType401 == nil || len(*vOneOfType401) == 0 || ((*vOneOfType401)[0].ObjectType_ != nil && "datapolicies.v4.config.RecoverySettingProjection" == *((*vOneOfType401)[0].ObjectType_)) { p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType2001 := new([]RecoverySetting) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if len(*vOneOfType2001) == 0 || (vOneOfType2001 != nil && (*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.RecoverySetting" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType401 := new([]RecoverySettingProjection) if err := json.Unmarshal(b, vOneOfType401); err == nil { if len(*vOneOfType401) == 0 || (vOneOfType401 != nil && (*vOneOfType401)[0].ObjectType_ != nil && "datapolicies.v4.config.RecoverySettingProjection" == *((*vOneOfType401)[0].ObjectType_)) { p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfListRecoverySettingsApiResponseData")) } func (p *OneOfListRecoverySettingsApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType2001) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType401) } return nil, errors.New("No value to marshal for OneOfListRecoverySettingsApiResponseData") } type OneOfDeleteProtectionPolicyApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfDeleteProtectionPolicyApiResponseData() *OneOfDeleteProtectionPolicyApiResponseData { p := new(OneOfDeleteProtectionPolicyApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfDeleteProtectionPolicyApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfDeleteProtectionPolicyApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfDeleteProtectionPolicyApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfDeleteProtectionPolicyApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfDeleteProtectionPolicyApiResponseData")) } func (p *OneOfDeleteProtectionPolicyApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfDeleteProtectionPolicyApiResponseData") } type OneOfGetRecoveryPlanApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType2001 *RecoveryPlan `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType401 *RecoveryPlanProjection `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfGetRecoveryPlanApiResponseData() *OneOfGetRecoveryPlanApiResponseData { p := new(OneOfGetRecoveryPlanApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfGetRecoveryPlanApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfGetRecoveryPlanApiResponseData is nil")) } switch v.(type) { case RecoveryPlan: if nil == p.oneOfType2001 { p.oneOfType2001 = new(RecoveryPlan) } *p.oneOfType2001 = v.(RecoveryPlan) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case RecoveryPlanProjection: if nil == p.oneOfType401 { p.oneOfType401 = new(RecoveryPlanProjection) } *p.oneOfType401 = v.(RecoveryPlanProjection) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfGetRecoveryPlanApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType401 != nil && *p.oneOfType401.ObjectType_ == *p.Discriminator { return *p.oneOfType401 } return nil } func (p *OneOfGetRecoveryPlanApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(RecoveryPlan) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.RecoveryPlan" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(RecoveryPlan) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType401 := new(RecoveryPlanProjection) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType401) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType401.ObjectType_ != nil && "datapolicies.v4.config.RecoveryPlanProjection" == *vOneOfType401.ObjectType_ { if nil == p.oneOfType401 { p.oneOfType401 = new(RecoveryPlanProjection) } *p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType2001 := new(RecoveryPlan) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.RecoveryPlan" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(RecoveryPlan) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType401 := new(RecoveryPlanProjection) if err := json.Unmarshal(b, vOneOfType401); err == nil { if vOneOfType401.ObjectType_ != nil && "datapolicies.v4.config.RecoveryPlanProjection" == *vOneOfType401.ObjectType_ { if nil == p.oneOfType401 { p.oneOfType401 = new(RecoveryPlanProjection) } *p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfGetRecoveryPlanApiResponseData")) } func (p *OneOfGetRecoveryPlanApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType401 != nil && *p.oneOfType401.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType401) } return nil, errors.New("No value to marshal for OneOfGetRecoveryPlanApiResponseData") } type OneOfEntitySyncPolicyGroupGroup struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType2005 *float64 `json:"-"` oneOfType2004 *int64 `json:"-"` oneOfType2002 *string `json:"-"` oneOfType2003 *int `json:"-"` oneOfType2006 *bool `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfEntitySyncPolicyGroupGroup() *OneOfEntitySyncPolicyGroupGroup { p := new(OneOfEntitySyncPolicyGroupGroup) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfEntitySyncPolicyGroupGroup) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfEntitySyncPolicyGroupGroup is nil")) } switch v.(type) { case float64: if nil == p.oneOfType2005 { p.oneOfType2005 = new(float64) } *p.oneOfType2005 = v.(float64) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Double" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Double" case int64: if nil == p.oneOfType2004 { p.oneOfType2004 = new(int64) } *p.oneOfType2004 = v.(int64) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Long" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Long" case string: if nil == p.oneOfType2002 { p.oneOfType2002 = new(string) } *p.oneOfType2002 = v.(string) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "String" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "String" case int: if nil == p.oneOfType2003 { p.oneOfType2003 = new(int) } *p.oneOfType2003 = v.(int) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Integer" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Integer" case bool: if nil == p.oneOfType2006 { p.oneOfType2006 = new(bool) } *p.oneOfType2006 = v.(bool) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Boolean" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Boolean" default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfEntitySyncPolicyGroupGroup) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if "Double" == *p.Discriminator { return *p.oneOfType2005 } if "Long" == *p.Discriminator { return *p.oneOfType2004 } if "String" == *p.Discriminator { return *p.oneOfType2002 } if "Integer" == *p.Discriminator { return *p.oneOfType2003 } if "Boolean" == *p.Discriminator { return *p.oneOfType2006 } return nil } func (p *OneOfEntitySyncPolicyGroupGroup) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["Double"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2005 := new(float64) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2005) if unmarshalErr == nil { if nil == p.oneOfType2005 { p.oneOfType2005 = new(float64) } *p.oneOfType2005 = *vOneOfType2005 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Double" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Double" return nil } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["Long"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2004 := new(int64) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2004) if unmarshalErr == nil { if nil == p.oneOfType2004 { p.oneOfType2004 = new(int64) } *p.oneOfType2004 = *vOneOfType2004 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Long" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Long" return nil } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["String"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2002 := new(string) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2002) if unmarshalErr == nil { if nil == p.oneOfType2002 { p.oneOfType2002 = new(string) } *p.oneOfType2002 = *vOneOfType2002 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "String" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "String" return nil } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["Integer"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2003 := new(int) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2003) if unmarshalErr == nil { if nil == p.oneOfType2003 { p.oneOfType2003 = new(int) } *p.oneOfType2003 = *vOneOfType2003 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Integer" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Integer" return nil } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["Boolean"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2006 := new(bool) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2006) if unmarshalErr == nil { if nil == p.oneOfType2006 { p.oneOfType2006 = new(bool) } *p.oneOfType2006 = *vOneOfType2006 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Boolean" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Boolean" return nil } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType2005 := new(float64) if err := json.Unmarshal(b, vOneOfType2005); err == nil { if nil == p.oneOfType2005 { p.oneOfType2005 = new(float64) } *p.oneOfType2005 = *vOneOfType2005 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Double" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Double" return nil } vOneOfType2004 := new(int64) if err := json.Unmarshal(b, vOneOfType2004); err == nil { if nil == p.oneOfType2004 { p.oneOfType2004 = new(int64) } *p.oneOfType2004 = *vOneOfType2004 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Long" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Long" return nil } vOneOfType2002 := new(string) if err := json.Unmarshal(b, vOneOfType2002); err == nil { if nil == p.oneOfType2002 { p.oneOfType2002 = new(string) } *p.oneOfType2002 = *vOneOfType2002 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "String" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "String" return nil } vOneOfType2003 := new(int) if err := json.Unmarshal(b, vOneOfType2003); err == nil { if nil == p.oneOfType2003 { p.oneOfType2003 = new(int) } *p.oneOfType2003 = *vOneOfType2003 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Integer" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Integer" return nil } vOneOfType2006 := new(bool) if err := json.Unmarshal(b, vOneOfType2006); err == nil { if nil == p.oneOfType2006 { p.oneOfType2006 = new(bool) } *p.oneOfType2006 = *vOneOfType2006 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "Boolean" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "Boolean" return nil } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfEntitySyncPolicyGroupGroup")) } func (p *OneOfEntitySyncPolicyGroupGroup) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if "Double" == *p.Discriminator { return json.Marshal(p.oneOfType2005) } if "Long" == *p.Discriminator { return json.Marshal(p.oneOfType2004) } if "String" == *p.Discriminator { return json.Marshal(p.oneOfType2002) } if "Integer" == *p.Discriminator { return json.Marshal(p.oneOfType2003) } if "Boolean" == *p.Discriminator { return json.Marshal(p.oneOfType2006) } return nil, errors.New("No value to marshal for OneOfEntitySyncPolicyGroupGroup") } type OneOfListRecoveryStagesApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 []RecoveryStage `json:"-"` oneOfType401 []RecoveryStageProjection `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfListRecoveryStagesApiResponseData() *OneOfListRecoveryStagesApiResponseData { p := new(OneOfListRecoveryStagesApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfListRecoveryStagesApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfListRecoveryStagesApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case []RecoveryStage: p.oneOfType2001 = v.([]RecoveryStage) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" case []RecoveryStageProjection: p.oneOfType401 = v.([]RecoveryStageProjection) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfListRecoveryStagesApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if "List" == *p.Discriminator { return p.oneOfType2001 } if "List" == *p.Discriminator { return p.oneOfType401 } return nil } func (p *OneOfListRecoveryStagesApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new([]RecoveryStage) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType2001 == nil || len(*vOneOfType2001) == 0 || ((*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.RecoveryStage" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType401 := new([]RecoveryStageProjection) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType401) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType401 == nil || len(*vOneOfType401) == 0 || ((*vOneOfType401)[0].ObjectType_ != nil && "datapolicies.v4.config.RecoveryStageProjection" == *((*vOneOfType401)[0].ObjectType_)) { p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new([]RecoveryStage) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if len(*vOneOfType2001) == 0 || (vOneOfType2001 != nil && (*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.RecoveryStage" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } vOneOfType401 := new([]RecoveryStageProjection) if err := json.Unmarshal(b, vOneOfType401); err == nil { if len(*vOneOfType401) == 0 || (vOneOfType401 != nil && (*vOneOfType401)[0].ObjectType_ != nil && "datapolicies.v4.config.RecoveryStageProjection" == *((*vOneOfType401)[0].ObjectType_)) { p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfListRecoveryStagesApiResponseData")) } func (p *OneOfListRecoveryStagesApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType2001) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType401) } return nil, errors.New("No value to marshal for OneOfListRecoveryStagesApiResponseData") } type OneOfScheduleRetention struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType2002 *AutoRollupRetention `json:"-"` oneOfType2001 *LinearRetention `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfScheduleRetention() *OneOfScheduleRetention { p := new(OneOfScheduleRetention) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfScheduleRetention) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfScheduleRetention is nil")) } switch v.(type) { case AutoRollupRetention: if nil == p.oneOfType2002 { p.oneOfType2002 = new(AutoRollupRetention) } *p.oneOfType2002 = v.(AutoRollupRetention) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2002.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2002.ObjectType_ case LinearRetention: if nil == p.oneOfType2001 { p.oneOfType2001 = new(LinearRetention) } *p.oneOfType2001 = v.(LinearRetention) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfScheduleRetention) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType2002 != nil && *p.oneOfType2002.ObjectType_ == *p.Discriminator { return *p.oneOfType2002 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfScheduleRetention) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2002 := new(AutoRollupRetention) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2002) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2002.ObjectType_ != nil && "datapolicies.v4.config.AutoRollupRetention" == *vOneOfType2002.ObjectType_ { if nil == p.oneOfType2002 { p.oneOfType2002 = new(AutoRollupRetention) } *p.oneOfType2002 = *vOneOfType2002 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2002.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2002.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(LinearRetention) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.LinearRetention" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(LinearRetention) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType2002 := new(AutoRollupRetention) if err := json.Unmarshal(b, vOneOfType2002); err == nil { if vOneOfType2002.ObjectType_ != nil && "datapolicies.v4.config.AutoRollupRetention" == *vOneOfType2002.ObjectType_ { if nil == p.oneOfType2002 { p.oneOfType2002 = new(AutoRollupRetention) } *p.oneOfType2002 = *vOneOfType2002 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2002.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2002.ObjectType_ return nil } } vOneOfType2001 := new(LinearRetention) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.LinearRetention" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(LinearRetention) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfScheduleRetention")) } func (p *OneOfScheduleRetention) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType2002 != nil && *p.oneOfType2002.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2002) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfScheduleRetention") } type OneOfStageActionConfig struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType20021 *DelayAction `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfStageActionConfig() *OneOfStageActionConfig { p := new(OneOfStageActionConfig) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfStageActionConfig) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfStageActionConfig is nil")) } switch v.(type) { case DelayAction: if nil == p.oneOfType20021 { p.oneOfType20021 = new(DelayAction) } *p.oneOfType20021 = v.(DelayAction) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20021.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20021.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfStageActionConfig) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType20021 != nil && *p.oneOfType20021.ObjectType_ == *p.Discriminator { return *p.oneOfType20021 } return nil } func (p *OneOfStageActionConfig) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType20021 := new(DelayAction) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType20021) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType20021.ObjectType_ != nil && "datapolicies.v4.config.DelayAction" == *vOneOfType20021.ObjectType_ { if nil == p.oneOfType20021 { p.oneOfType20021 = new(DelayAction) } *p.oneOfType20021 = *vOneOfType20021 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20021.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20021.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType20021 := new(DelayAction) if err := json.Unmarshal(b, vOneOfType20021); err == nil { if vOneOfType20021.ObjectType_ != nil && "datapolicies.v4.config.DelayAction" == *vOneOfType20021.ObjectType_ { if nil == p.oneOfType20021 { p.oneOfType20021 = new(DelayAction) } *p.oneOfType20021 = *vOneOfType20021 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20021.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20021.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfStageActionConfig")) } func (p *OneOfStageActionConfig) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType20021 != nil && *p.oneOfType20021.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType20021) } return nil, errors.New("No value to marshal for OneOfStageActionConfig") } type OneOfListEntitySyncPoliciesApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType402 []EntitySyncPolicyGroup `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType401 []EntitySyncPolicyProjection `json:"-"` oneOfType2001 []EntitySyncPolicy `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfListEntitySyncPoliciesApiResponseData() *OneOfListEntitySyncPoliciesApiResponseData { p := new(OneOfListEntitySyncPoliciesApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfListEntitySyncPoliciesApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfListEntitySyncPoliciesApiResponseData is nil")) } switch v.(type) { case []EntitySyncPolicyGroup: p.oneOfType402 = v.([]EntitySyncPolicyGroup) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case []EntitySyncPolicyProjection: p.oneOfType401 = v.([]EntitySyncPolicyProjection) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" case []EntitySyncPolicy: p.oneOfType2001 = v.([]EntitySyncPolicy) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfListEntitySyncPoliciesApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if "List" == *p.Discriminator { return p.oneOfType402 } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if "List" == *p.Discriminator { return p.oneOfType401 } if "List" == *p.Discriminator { return p.oneOfType2001 } return nil } func (p *OneOfListEntitySyncPoliciesApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType402 := new([]EntitySyncPolicyGroup) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType402) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType402 == nil || len(*vOneOfType402) == 0 || ((*vOneOfType402)[0].ObjectType_ != nil && "datapolicies.v4.config.EntitySyncPolicyGroup" == *((*vOneOfType402)[0].ObjectType_)) { p.oneOfType402 = *vOneOfType402 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType401 := new([]EntitySyncPolicyProjection) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType401) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType401 == nil || len(*vOneOfType401) == 0 || ((*vOneOfType401)[0].ObjectType_ != nil && "datapolicies.v4.config.EntitySyncPolicyProjection" == *((*vOneOfType401)[0].ObjectType_)) { p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new([]EntitySyncPolicy) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType2001 == nil || len(*vOneOfType2001) == 0 || ((*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.EntitySyncPolicy" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType402 := new([]EntitySyncPolicyGroup) if err := json.Unmarshal(b, vOneOfType402); err == nil { if len(*vOneOfType402) == 0 || (vOneOfType402 != nil && (*vOneOfType402)[0].ObjectType_ != nil && "datapolicies.v4.config.EntitySyncPolicyGroup" == *((*vOneOfType402)[0].ObjectType_)) { p.oneOfType402 = *vOneOfType402 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType401 := new([]EntitySyncPolicyProjection) if err := json.Unmarshal(b, vOneOfType401); err == nil { if len(*vOneOfType401) == 0 || (vOneOfType401 != nil && (*vOneOfType401)[0].ObjectType_ != nil && "datapolicies.v4.config.EntitySyncPolicyProjection" == *((*vOneOfType401)[0].ObjectType_)) { p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } vOneOfType2001 := new([]EntitySyncPolicy) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if len(*vOneOfType2001) == 0 || (vOneOfType2001 != nil && (*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.EntitySyncPolicy" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfListEntitySyncPoliciesApiResponseData")) } func (p *OneOfListEntitySyncPoliciesApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType402) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType401) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfListEntitySyncPoliciesApiResponseData") } type OneOfReplicationLocationReplicationSubLocation struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType2101 *NutanixCluster `json:"-"` oneOfType2102 *Mst `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfReplicationLocationReplicationSubLocation() *OneOfReplicationLocationReplicationSubLocation { p := new(OneOfReplicationLocationReplicationSubLocation) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfReplicationLocationReplicationSubLocation) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfReplicationLocationReplicationSubLocation is nil")) } switch v.(type) { case NutanixCluster: if nil == p.oneOfType2101 { p.oneOfType2101 = new(NutanixCluster) } *p.oneOfType2101 = v.(NutanixCluster) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2101.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2101.ObjectType_ case Mst: if nil == p.oneOfType2102 { p.oneOfType2102 = new(Mst) } *p.oneOfType2102 = v.(Mst) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2102.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2102.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfReplicationLocationReplicationSubLocation) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType2101 != nil && *p.oneOfType2101.ObjectType_ == *p.Discriminator { return *p.oneOfType2101 } if p.oneOfType2102 != nil && *p.oneOfType2102.ObjectType_ == *p.Discriminator { return *p.oneOfType2102 } return nil } func (p *OneOfReplicationLocationReplicationSubLocation) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2101 := new(NutanixCluster) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2101) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2101.ObjectType_ != nil && "datapolicies.v4.config.NutanixCluster" == *vOneOfType2101.ObjectType_ { if nil == p.oneOfType2101 { p.oneOfType2101 = new(NutanixCluster) } *p.oneOfType2101 = *vOneOfType2101 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2101.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2101.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2102 := new(Mst) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2102) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2102.ObjectType_ != nil && "datapolicies.v4.config.Mst" == *vOneOfType2102.ObjectType_ { if nil == p.oneOfType2102 { p.oneOfType2102 = new(Mst) } *p.oneOfType2102 = *vOneOfType2102 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2102.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2102.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType2101 := new(NutanixCluster) if err := json.Unmarshal(b, vOneOfType2101); err == nil { if vOneOfType2101.ObjectType_ != nil && "datapolicies.v4.config.NutanixCluster" == *vOneOfType2101.ObjectType_ { if nil == p.oneOfType2101 { p.oneOfType2101 = new(NutanixCluster) } *p.oneOfType2101 = *vOneOfType2101 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2101.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2101.ObjectType_ return nil } } vOneOfType2102 := new(Mst) if err := json.Unmarshal(b, vOneOfType2102); err == nil { if vOneOfType2102.ObjectType_ != nil && "datapolicies.v4.config.Mst" == *vOneOfType2102.ObjectType_ { if nil == p.oneOfType2102 { p.oneOfType2102 = new(Mst) } *p.oneOfType2102 = *vOneOfType2102 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2102.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2102.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfReplicationLocationReplicationSubLocation")) } func (p *OneOfReplicationLocationReplicationSubLocation) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType2101 != nil && *p.oneOfType2101.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2101) } if p.oneOfType2102 != nil && *p.oneOfType2102.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2102) } return nil, errors.New("No value to marshal for OneOfReplicationLocationReplicationSubLocation") } type OneOfCreateStoragePolicyApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfCreateStoragePolicyApiResponseData() *OneOfCreateStoragePolicyApiResponseData { p := new(OneOfCreateStoragePolicyApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfCreateStoragePolicyApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfCreateStoragePolicyApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfCreateStoragePolicyApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfCreateStoragePolicyApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfCreateStoragePolicyApiResponseData")) } func (p *OneOfCreateStoragePolicyApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfCreateStoragePolicyApiResponseData") } type OneOfVolumeGroupAttachmentClientFeatures struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType20041 *IscsiFeatures `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfVolumeGroupAttachmentClientFeatures() *OneOfVolumeGroupAttachmentClientFeatures { p := new(OneOfVolumeGroupAttachmentClientFeatures) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfVolumeGroupAttachmentClientFeatures) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfVolumeGroupAttachmentClientFeatures is nil")) } switch v.(type) { case IscsiFeatures: if nil == p.oneOfType20041 { p.oneOfType20041 = new(IscsiFeatures) } *p.oneOfType20041 = v.(IscsiFeatures) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20041.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20041.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfVolumeGroupAttachmentClientFeatures) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType20041 != nil && *p.oneOfType20041.ObjectType_ == *p.Discriminator { return *p.oneOfType20041 } return nil } func (p *OneOfVolumeGroupAttachmentClientFeatures) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType20041 := new(IscsiFeatures) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType20041) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType20041.ObjectType_ != nil && "datapolicies.v4.config.IscsiFeatures" == *vOneOfType20041.ObjectType_ { if nil == p.oneOfType20041 { p.oneOfType20041 = new(IscsiFeatures) } *p.oneOfType20041 = *vOneOfType20041 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20041.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20041.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType20041 := new(IscsiFeatures) if err := json.Unmarshal(b, vOneOfType20041); err == nil { if vOneOfType20041.ObjectType_ != nil && "datapolicies.v4.config.IscsiFeatures" == *vOneOfType20041.ObjectType_ { if nil == p.oneOfType20041 { p.oneOfType20041 = new(IscsiFeatures) } *p.oneOfType20041 = *vOneOfType20041 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20041.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20041.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfVolumeGroupAttachmentClientFeatures")) } func (p *OneOfVolumeGroupAttachmentClientFeatures) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType20041 != nil && *p.oneOfType20041.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType20041) } return nil, errors.New("No value to marshal for OneOfVolumeGroupAttachmentClientFeatures") } type OneOfGetEntitySyncPolicyApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType2001 *EntitySyncPolicy `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType401 *EntitySyncPolicyProjection `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfGetEntitySyncPolicyApiResponseData() *OneOfGetEntitySyncPolicyApiResponseData { p := new(OneOfGetEntitySyncPolicyApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfGetEntitySyncPolicyApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfGetEntitySyncPolicyApiResponseData is nil")) } switch v.(type) { case EntitySyncPolicy: if nil == p.oneOfType2001 { p.oneOfType2001 = new(EntitySyncPolicy) } *p.oneOfType2001 = v.(EntitySyncPolicy) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case EntitySyncPolicyProjection: if nil == p.oneOfType401 { p.oneOfType401 = new(EntitySyncPolicyProjection) } *p.oneOfType401 = v.(EntitySyncPolicyProjection) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfGetEntitySyncPolicyApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType401 != nil && *p.oneOfType401.ObjectType_ == *p.Discriminator { return *p.oneOfType401 } return nil } func (p *OneOfGetEntitySyncPolicyApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(EntitySyncPolicy) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.EntitySyncPolicy" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(EntitySyncPolicy) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType401 := new(EntitySyncPolicyProjection) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType401) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType401.ObjectType_ != nil && "datapolicies.v4.config.EntitySyncPolicyProjection" == *vOneOfType401.ObjectType_ { if nil == p.oneOfType401 { p.oneOfType401 = new(EntitySyncPolicyProjection) } *p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType2001 := new(EntitySyncPolicy) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.EntitySyncPolicy" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(EntitySyncPolicy) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType401 := new(EntitySyncPolicyProjection) if err := json.Unmarshal(b, vOneOfType401); err == nil { if vOneOfType401.ObjectType_ != nil && "datapolicies.v4.config.EntitySyncPolicyProjection" == *vOneOfType401.ObjectType_ { if nil == p.oneOfType401 { p.oneOfType401 = new(EntitySyncPolicyProjection) } *p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfGetEntitySyncPolicyApiResponseData")) } func (p *OneOfGetEntitySyncPolicyApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType401 != nil && *p.oneOfType401.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType401) } return nil, errors.New("No value to marshal for OneOfGetEntitySyncPolicyApiResponseData") } type OneOfListRecoveryPlansApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 []RecoveryPlan `json:"-"` oneOfType401 []RecoveryPlanProjection `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfListRecoveryPlansApiResponseData() *OneOfListRecoveryPlansApiResponseData { p := new(OneOfListRecoveryPlansApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfListRecoveryPlansApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfListRecoveryPlansApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case []RecoveryPlan: p.oneOfType2001 = v.([]RecoveryPlan) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" case []RecoveryPlanProjection: p.oneOfType401 = v.([]RecoveryPlanProjection) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfListRecoveryPlansApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if "List" == *p.Discriminator { return p.oneOfType2001 } if "List" == *p.Discriminator { return p.oneOfType401 } return nil } func (p *OneOfListRecoveryPlansApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new([]RecoveryPlan) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType2001 == nil || len(*vOneOfType2001) == 0 || ((*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.RecoveryPlan" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType401 := new([]RecoveryPlanProjection) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType401) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType401 == nil || len(*vOneOfType401) == 0 || ((*vOneOfType401)[0].ObjectType_ != nil && "datapolicies.v4.config.RecoveryPlanProjection" == *((*vOneOfType401)[0].ObjectType_)) { p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new([]RecoveryPlan) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if len(*vOneOfType2001) == 0 || (vOneOfType2001 != nil && (*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.RecoveryPlan" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } vOneOfType401 := new([]RecoveryPlanProjection) if err := json.Unmarshal(b, vOneOfType401); err == nil { if len(*vOneOfType401) == 0 || (vOneOfType401 != nil && (*vOneOfType401)[0].ObjectType_ != nil && "datapolicies.v4.config.RecoveryPlanProjection" == *((*vOneOfType401)[0].ObjectType_)) { p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfListRecoveryPlansApiResponseData")) } func (p *OneOfListRecoveryPlansApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType2001) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType401) } return nil, errors.New("No value to marshal for OneOfListRecoveryPlansApiResponseData") } type OneOfListNetworkMappingsApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType2001 []NetworkMapping `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType401 []NetworkMappingProjection `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfListNetworkMappingsApiResponseData() *OneOfListNetworkMappingsApiResponseData { p := new(OneOfListNetworkMappingsApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfListNetworkMappingsApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfListNetworkMappingsApiResponseData is nil")) } switch v.(type) { case []NetworkMapping: p.oneOfType2001 = v.([]NetworkMapping) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case []NetworkMappingProjection: p.oneOfType401 = v.([]NetworkMappingProjection) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfListNetworkMappingsApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if "List" == *p.Discriminator { return p.oneOfType2001 } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if "List" == *p.Discriminator { return p.oneOfType401 } return nil } func (p *OneOfListNetworkMappingsApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new([]NetworkMapping) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType2001 == nil || len(*vOneOfType2001) == 0 || ((*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.NetworkMapping" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType401 := new([]NetworkMappingProjection) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType401) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType401 == nil || len(*vOneOfType401) == 0 || ((*vOneOfType401)[0].ObjectType_ != nil && "datapolicies.v4.config.NetworkMappingProjection" == *((*vOneOfType401)[0].ObjectType_)) { p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType2001 := new([]NetworkMapping) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if len(*vOneOfType2001) == 0 || (vOneOfType2001 != nil && (*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.NetworkMapping" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType401 := new([]NetworkMappingProjection) if err := json.Unmarshal(b, vOneOfType401); err == nil { if len(*vOneOfType401) == 0 || (vOneOfType401 != nil && (*vOneOfType401)[0].ObjectType_ != nil && "datapolicies.v4.config.NetworkMappingProjection" == *((*vOneOfType401)[0].ObjectType_)) { p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfListNetworkMappingsApiResponseData")) } func (p *OneOfListNetworkMappingsApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType2001) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType401) } return nil, errors.New("No value to marshal for OneOfListNetworkMappingsApiResponseData") } type OneOfUpdateStoragePolicyApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfUpdateStoragePolicyApiResponseData() *OneOfUpdateStoragePolicyApiResponseData { p := new(OneOfUpdateStoragePolicyApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfUpdateStoragePolicyApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfUpdateStoragePolicyApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfUpdateStoragePolicyApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfUpdateStoragePolicyApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfUpdateStoragePolicyApiResponseData")) } func (p *OneOfUpdateStoragePolicyApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfUpdateStoragePolicyApiResponseData") } type OneOfGetRecoveryStageApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType401 *RecoveryStageProjection `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *RecoveryStage `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfGetRecoveryStageApiResponseData() *OneOfGetRecoveryStageApiResponseData { p := new(OneOfGetRecoveryStageApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfGetRecoveryStageApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfGetRecoveryStageApiResponseData is nil")) } switch v.(type) { case RecoveryStageProjection: if nil == p.oneOfType401 { p.oneOfType401 = new(RecoveryStageProjection) } *p.oneOfType401 = v.(RecoveryStageProjection) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case RecoveryStage: if nil == p.oneOfType2001 { p.oneOfType2001 = new(RecoveryStage) } *p.oneOfType2001 = v.(RecoveryStage) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfGetRecoveryStageApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType401 != nil && *p.oneOfType401.ObjectType_ == *p.Discriminator { return *p.oneOfType401 } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfGetRecoveryStageApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType401 := new(RecoveryStageProjection) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType401) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType401.ObjectType_ != nil && "datapolicies.v4.config.RecoveryStageProjection" == *vOneOfType401.ObjectType_ { if nil == p.oneOfType401 { p.oneOfType401 = new(RecoveryStageProjection) } *p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(RecoveryStage) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.RecoveryStage" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(RecoveryStage) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType401 := new(RecoveryStageProjection) if err := json.Unmarshal(b, vOneOfType401); err == nil { if vOneOfType401.ObjectType_ != nil && "datapolicies.v4.config.RecoveryStageProjection" == *vOneOfType401.ObjectType_ { if nil == p.oneOfType401 { p.oneOfType401 = new(RecoveryStageProjection) } *p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ return nil } } vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(RecoveryStage) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.RecoveryStage" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(RecoveryStage) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfGetRecoveryStageApiResponseData")) } func (p *OneOfGetRecoveryStageApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType401 != nil && *p.oneOfType401.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType401) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfGetRecoveryStageApiResponseData") } type OneOfCreateRecoveryStageApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfCreateRecoveryStageApiResponseData() *OneOfCreateRecoveryStageApiResponseData { p := new(OneOfCreateRecoveryStageApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfCreateRecoveryStageApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfCreateRecoveryStageApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfCreateRecoveryStageApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfCreateRecoveryStageApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfCreateRecoveryStageApiResponseData")) } func (p *OneOfCreateRecoveryStageApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfCreateRecoveryStageApiResponseData") } type OneOfSyncEntitySyncPolicyApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfSyncEntitySyncPolicyApiResponseData() *OneOfSyncEntitySyncPolicyApiResponseData { p := new(OneOfSyncEntitySyncPolicyApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfSyncEntitySyncPolicyApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfSyncEntitySyncPolicyApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfSyncEntitySyncPolicyApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfSyncEntitySyncPolicyApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfSyncEntitySyncPolicyApiResponseData")) } func (p *OneOfSyncEntitySyncPolicyApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfSyncEntitySyncPolicyApiResponseData") } type OneOfGetRecoverySettingApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *RecoverySetting `json:"-"` oneOfType401 *RecoverySettingProjection `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfGetRecoverySettingApiResponseData() *OneOfGetRecoverySettingApiResponseData { p := new(OneOfGetRecoverySettingApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfGetRecoverySettingApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfGetRecoverySettingApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case RecoverySetting: if nil == p.oneOfType2001 { p.oneOfType2001 = new(RecoverySetting) } *p.oneOfType2001 = v.(RecoverySetting) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ case RecoverySettingProjection: if nil == p.oneOfType401 { p.oneOfType401 = new(RecoverySettingProjection) } *p.oneOfType401 = v.(RecoverySettingProjection) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfGetRecoverySettingApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } if p.oneOfType401 != nil && *p.oneOfType401.ObjectType_ == *p.Discriminator { return *p.oneOfType401 } return nil } func (p *OneOfGetRecoverySettingApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(RecoverySetting) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.RecoverySetting" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(RecoverySetting) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType401 := new(RecoverySettingProjection) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType401) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType401.ObjectType_ != nil && "datapolicies.v4.config.RecoverySettingProjection" == *vOneOfType401.ObjectType_ { if nil == p.oneOfType401 { p.oneOfType401 = new(RecoverySettingProjection) } *p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(RecoverySetting) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.RecoverySetting" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(RecoverySetting) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } vOneOfType401 := new(RecoverySettingProjection) if err := json.Unmarshal(b, vOneOfType401); err == nil { if vOneOfType401.ObjectType_ != nil && "datapolicies.v4.config.RecoverySettingProjection" == *vOneOfType401.ObjectType_ { if nil == p.oneOfType401 { p.oneOfType401 = new(RecoverySettingProjection) } *p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfGetRecoverySettingApiResponseData")) } func (p *OneOfGetRecoverySettingApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } if p.oneOfType401 != nil && *p.oneOfType401.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType401) } return nil, errors.New("No value to marshal for OneOfGetRecoverySettingApiResponseData") } type OneOfRecoverySettingProjectionRecoverySetting struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType20031 *VmRecoverySetting `json:"-"` oneOfType20033 *VolumeGroupRecoverySetting `json:"-"` oneOfType20032 *VmCategoryRecoverySetting `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfRecoverySettingProjectionRecoverySetting() *OneOfRecoverySettingProjectionRecoverySetting { p := new(OneOfRecoverySettingProjectionRecoverySetting) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfRecoverySettingProjectionRecoverySetting) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfRecoverySettingProjectionRecoverySetting is nil")) } switch v.(type) { case VmRecoverySetting: if nil == p.oneOfType20031 { p.oneOfType20031 = new(VmRecoverySetting) } *p.oneOfType20031 = v.(VmRecoverySetting) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20031.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20031.ObjectType_ case VolumeGroupRecoverySetting: if nil == p.oneOfType20033 { p.oneOfType20033 = new(VolumeGroupRecoverySetting) } *p.oneOfType20033 = v.(VolumeGroupRecoverySetting) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20033.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20033.ObjectType_ case VmCategoryRecoverySetting: if nil == p.oneOfType20032 { p.oneOfType20032 = new(VmCategoryRecoverySetting) } *p.oneOfType20032 = v.(VmCategoryRecoverySetting) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20032.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20032.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfRecoverySettingProjectionRecoverySetting) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType20031 != nil && *p.oneOfType20031.ObjectType_ == *p.Discriminator { return *p.oneOfType20031 } if p.oneOfType20033 != nil && *p.oneOfType20033.ObjectType_ == *p.Discriminator { return *p.oneOfType20033 } if p.oneOfType20032 != nil && *p.oneOfType20032.ObjectType_ == *p.Discriminator { return *p.oneOfType20032 } return nil } func (p *OneOfRecoverySettingProjectionRecoverySetting) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType20031 := new(VmRecoverySetting) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType20031) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType20031.ObjectType_ != nil && "datapolicies.v4.config.VmRecoverySetting" == *vOneOfType20031.ObjectType_ { if nil == p.oneOfType20031 { p.oneOfType20031 = new(VmRecoverySetting) } *p.oneOfType20031 = *vOneOfType20031 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20031.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20031.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType20033 := new(VolumeGroupRecoverySetting) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType20033) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType20033.ObjectType_ != nil && "datapolicies.v4.config.VolumeGroupRecoverySetting" == *vOneOfType20033.ObjectType_ { if nil == p.oneOfType20033 { p.oneOfType20033 = new(VolumeGroupRecoverySetting) } *p.oneOfType20033 = *vOneOfType20033 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20033.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20033.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType20032 := new(VmCategoryRecoverySetting) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType20032) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType20032.ObjectType_ != nil && "datapolicies.v4.config.VmCategoryRecoverySetting" == *vOneOfType20032.ObjectType_ { if nil == p.oneOfType20032 { p.oneOfType20032 = new(VmCategoryRecoverySetting) } *p.oneOfType20032 = *vOneOfType20032 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20032.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20032.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType20031 := new(VmRecoverySetting) if err := json.Unmarshal(b, vOneOfType20031); err == nil { if vOneOfType20031.ObjectType_ != nil && "datapolicies.v4.config.VmRecoverySetting" == *vOneOfType20031.ObjectType_ { if nil == p.oneOfType20031 { p.oneOfType20031 = new(VmRecoverySetting) } *p.oneOfType20031 = *vOneOfType20031 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20031.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20031.ObjectType_ return nil } } vOneOfType20033 := new(VolumeGroupRecoverySetting) if err := json.Unmarshal(b, vOneOfType20033); err == nil { if vOneOfType20033.ObjectType_ != nil && "datapolicies.v4.config.VolumeGroupRecoverySetting" == *vOneOfType20033.ObjectType_ { if nil == p.oneOfType20033 { p.oneOfType20033 = new(VolumeGroupRecoverySetting) } *p.oneOfType20033 = *vOneOfType20033 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20033.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20033.ObjectType_ return nil } } vOneOfType20032 := new(VmCategoryRecoverySetting) if err := json.Unmarshal(b, vOneOfType20032); err == nil { if vOneOfType20032.ObjectType_ != nil && "datapolicies.v4.config.VmCategoryRecoverySetting" == *vOneOfType20032.ObjectType_ { if nil == p.oneOfType20032 { p.oneOfType20032 = new(VmCategoryRecoverySetting) } *p.oneOfType20032 = *vOneOfType20032 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20032.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20032.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfRecoverySettingProjectionRecoverySetting")) } func (p *OneOfRecoverySettingProjectionRecoverySetting) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType20031 != nil && *p.oneOfType20031.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType20031) } if p.oneOfType20033 != nil && *p.oneOfType20033.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType20033) } if p.oneOfType20032 != nil && *p.oneOfType20032.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType20032) } return nil, errors.New("No value to marshal for OneOfRecoverySettingProjectionRecoverySetting") } type OneOfUpdateConsistencyRuleApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfUpdateConsistencyRuleApiResponseData() *OneOfUpdateConsistencyRuleApiResponseData { p := new(OneOfUpdateConsistencyRuleApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfUpdateConsistencyRuleApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfUpdateConsistencyRuleApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfUpdateConsistencyRuleApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfUpdateConsistencyRuleApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfUpdateConsistencyRuleApiResponseData")) } func (p *OneOfUpdateConsistencyRuleApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfUpdateConsistencyRuleApiResponseData") } type OneOfCreateConsistencyRuleApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfCreateConsistencyRuleApiResponseData() *OneOfCreateConsistencyRuleApiResponseData { p := new(OneOfCreateConsistencyRuleApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfCreateConsistencyRuleApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfCreateConsistencyRuleApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfCreateConsistencyRuleApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfCreateConsistencyRuleApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfCreateConsistencyRuleApiResponseData")) } func (p *OneOfCreateConsistencyRuleApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfCreateConsistencyRuleApiResponseData") } type OneOfDeleteRecoveryPlanApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfDeleteRecoveryPlanApiResponseData() *OneOfDeleteRecoveryPlanApiResponseData { p := new(OneOfDeleteRecoveryPlanApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfDeleteRecoveryPlanApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfDeleteRecoveryPlanApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfDeleteRecoveryPlanApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfDeleteRecoveryPlanApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfDeleteRecoveryPlanApiResponseData")) } func (p *OneOfDeleteRecoveryPlanApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfDeleteRecoveryPlanApiResponseData") } type OneOfDeleteConsistencyRuleApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfDeleteConsistencyRuleApiResponseData() *OneOfDeleteConsistencyRuleApiResponseData { p := new(OneOfDeleteConsistencyRuleApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfDeleteConsistencyRuleApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfDeleteConsistencyRuleApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfDeleteConsistencyRuleApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfDeleteConsistencyRuleApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfDeleteConsistencyRuleApiResponseData")) } func (p *OneOfDeleteConsistencyRuleApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfDeleteConsistencyRuleApiResponseData") } type OneOfDeleteDataServicesIpMappingApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfDeleteDataServicesIpMappingApiResponseData() *OneOfDeleteDataServicesIpMappingApiResponseData { p := new(OneOfDeleteDataServicesIpMappingApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfDeleteDataServicesIpMappingApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfDeleteDataServicesIpMappingApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfDeleteDataServicesIpMappingApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfDeleteDataServicesIpMappingApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfDeleteDataServicesIpMappingApiResponseData")) } func (p *OneOfDeleteDataServicesIpMappingApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfDeleteDataServicesIpMappingApiResponseData") } type OneOfUpdateRecoverySettingApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfUpdateRecoverySettingApiResponseData() *OneOfUpdateRecoverySettingApiResponseData { p := new(OneOfUpdateRecoverySettingApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfUpdateRecoverySettingApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfUpdateRecoverySettingApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfUpdateRecoverySettingApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfUpdateRecoverySettingApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfUpdateRecoverySettingApiResponseData")) } func (p *OneOfUpdateRecoverySettingApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfUpdateRecoverySettingApiResponseData") } type OneOfEntitySyncPolicyGroupData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType2008 []EntitySyncPolicy `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfEntitySyncPolicyGroupData() *OneOfEntitySyncPolicyGroupData { p := new(OneOfEntitySyncPolicyGroupData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfEntitySyncPolicyGroupData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfEntitySyncPolicyGroupData is nil")) } switch v.(type) { case []EntitySyncPolicy: p.oneOfType2008 = v.([]EntitySyncPolicy) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfEntitySyncPolicyGroupData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if "List" == *p.Discriminator { return p.oneOfType2008 } return nil } func (p *OneOfEntitySyncPolicyGroupData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2008 := new([]EntitySyncPolicy) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2008) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType2008 == nil || len(*vOneOfType2008) == 0 || ((*vOneOfType2008)[0].ObjectType_ != nil && "datapolicies.v4.config.EntitySyncPolicy" == *((*vOneOfType2008)[0].ObjectType_)) { p.oneOfType2008 = *vOneOfType2008 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType2008 := new([]EntitySyncPolicy) if err := json.Unmarshal(b, vOneOfType2008); err == nil { if len(*vOneOfType2008) == 0 || (vOneOfType2008 != nil && (*vOneOfType2008)[0].ObjectType_ != nil && "datapolicies.v4.config.EntitySyncPolicy" == *((*vOneOfType2008)[0].ObjectType_)) { p.oneOfType2008 = *vOneOfType2008 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfEntitySyncPolicyGroupData")) } func (p *OneOfEntitySyncPolicyGroupData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType2008) } return nil, errors.New("No value to marshal for OneOfEntitySyncPolicyGroupData") } type OneOfCreateRecoverySettingApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfCreateRecoverySettingApiResponseData() *OneOfCreateRecoverySettingApiResponseData { p := new(OneOfCreateRecoverySettingApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfCreateRecoverySettingApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfCreateRecoverySettingApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfCreateRecoverySettingApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfCreateRecoverySettingApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfCreateRecoverySettingApiResponseData")) } func (p *OneOfCreateRecoverySettingApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfCreateRecoverySettingApiResponseData") } type OneOfDeleteNetworkMappingApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfDeleteNetworkMappingApiResponseData() *OneOfDeleteNetworkMappingApiResponseData { p := new(OneOfDeleteNetworkMappingApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfDeleteNetworkMappingApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfDeleteNetworkMappingApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfDeleteNetworkMappingApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfDeleteNetworkMappingApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfDeleteNetworkMappingApiResponseData")) } func (p *OneOfDeleteNetworkMappingApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfDeleteNetworkMappingApiResponseData") } type OneOfRecoverySettingRecoverySetting struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType20031 *VmRecoverySetting `json:"-"` oneOfType20033 *VolumeGroupRecoverySetting `json:"-"` oneOfType20032 *VmCategoryRecoverySetting `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfRecoverySettingRecoverySetting() *OneOfRecoverySettingRecoverySetting { p := new(OneOfRecoverySettingRecoverySetting) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfRecoverySettingRecoverySetting) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfRecoverySettingRecoverySetting is nil")) } switch v.(type) { case VmRecoverySetting: if nil == p.oneOfType20031 { p.oneOfType20031 = new(VmRecoverySetting) } *p.oneOfType20031 = v.(VmRecoverySetting) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20031.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20031.ObjectType_ case VolumeGroupRecoverySetting: if nil == p.oneOfType20033 { p.oneOfType20033 = new(VolumeGroupRecoverySetting) } *p.oneOfType20033 = v.(VolumeGroupRecoverySetting) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20033.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20033.ObjectType_ case VmCategoryRecoverySetting: if nil == p.oneOfType20032 { p.oneOfType20032 = new(VmCategoryRecoverySetting) } *p.oneOfType20032 = v.(VmCategoryRecoverySetting) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20032.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20032.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfRecoverySettingRecoverySetting) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType20031 != nil && *p.oneOfType20031.ObjectType_ == *p.Discriminator { return *p.oneOfType20031 } if p.oneOfType20033 != nil && *p.oneOfType20033.ObjectType_ == *p.Discriminator { return *p.oneOfType20033 } if p.oneOfType20032 != nil && *p.oneOfType20032.ObjectType_ == *p.Discriminator { return *p.oneOfType20032 } return nil } func (p *OneOfRecoverySettingRecoverySetting) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType20031 := new(VmRecoverySetting) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType20031) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType20031.ObjectType_ != nil && "datapolicies.v4.config.VmRecoverySetting" == *vOneOfType20031.ObjectType_ { if nil == p.oneOfType20031 { p.oneOfType20031 = new(VmRecoverySetting) } *p.oneOfType20031 = *vOneOfType20031 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20031.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20031.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType20033 := new(VolumeGroupRecoverySetting) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType20033) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType20033.ObjectType_ != nil && "datapolicies.v4.config.VolumeGroupRecoverySetting" == *vOneOfType20033.ObjectType_ { if nil == p.oneOfType20033 { p.oneOfType20033 = new(VolumeGroupRecoverySetting) } *p.oneOfType20033 = *vOneOfType20033 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20033.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20033.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType20032 := new(VmCategoryRecoverySetting) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType20032) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType20032.ObjectType_ != nil && "datapolicies.v4.config.VmCategoryRecoverySetting" == *vOneOfType20032.ObjectType_ { if nil == p.oneOfType20032 { p.oneOfType20032 = new(VmCategoryRecoverySetting) } *p.oneOfType20032 = *vOneOfType20032 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20032.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20032.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType20031 := new(VmRecoverySetting) if err := json.Unmarshal(b, vOneOfType20031); err == nil { if vOneOfType20031.ObjectType_ != nil && "datapolicies.v4.config.VmRecoverySetting" == *vOneOfType20031.ObjectType_ { if nil == p.oneOfType20031 { p.oneOfType20031 = new(VmRecoverySetting) } *p.oneOfType20031 = *vOneOfType20031 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20031.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20031.ObjectType_ return nil } } vOneOfType20033 := new(VolumeGroupRecoverySetting) if err := json.Unmarshal(b, vOneOfType20033); err == nil { if vOneOfType20033.ObjectType_ != nil && "datapolicies.v4.config.VolumeGroupRecoverySetting" == *vOneOfType20033.ObjectType_ { if nil == p.oneOfType20033 { p.oneOfType20033 = new(VolumeGroupRecoverySetting) } *p.oneOfType20033 = *vOneOfType20033 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20033.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20033.ObjectType_ return nil } } vOneOfType20032 := new(VmCategoryRecoverySetting) if err := json.Unmarshal(b, vOneOfType20032); err == nil { if vOneOfType20032.ObjectType_ != nil && "datapolicies.v4.config.VmCategoryRecoverySetting" == *vOneOfType20032.ObjectType_ { if nil == p.oneOfType20032 { p.oneOfType20032 = new(VmCategoryRecoverySetting) } *p.oneOfType20032 = *vOneOfType20032 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType20032.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType20032.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfRecoverySettingRecoverySetting")) } func (p *OneOfRecoverySettingRecoverySetting) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType20031 != nil && *p.oneOfType20031.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType20031) } if p.oneOfType20033 != nil && *p.oneOfType20033.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType20033) } if p.oneOfType20032 != nil && *p.oneOfType20032.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType20032) } return nil, errors.New("No value to marshal for OneOfRecoverySettingRecoverySetting") } type OneOfCreateRecoveryPlanApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfCreateRecoveryPlanApiResponseData() *OneOfCreateRecoveryPlanApiResponseData { p := new(OneOfCreateRecoveryPlanApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfCreateRecoveryPlanApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfCreateRecoveryPlanApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfCreateRecoveryPlanApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfCreateRecoveryPlanApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfCreateRecoveryPlanApiResponseData")) } func (p *OneOfCreateRecoveryPlanApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfCreateRecoveryPlanApiResponseData") } type OneOfListProtectionPoliciesApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType401 []ProtectionPolicyProjection `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 []ProtectionPolicy `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfListProtectionPoliciesApiResponseData() *OneOfListProtectionPoliciesApiResponseData { p := new(OneOfListProtectionPoliciesApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfListProtectionPoliciesApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfListProtectionPoliciesApiResponseData is nil")) } switch v.(type) { case []ProtectionPolicyProjection: p.oneOfType401 = v.([]ProtectionPolicyProjection) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case []ProtectionPolicy: p.oneOfType2001 = v.([]ProtectionPolicy) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfListProtectionPoliciesApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if "List" == *p.Discriminator { return p.oneOfType401 } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if "List" == *p.Discriminator { return p.oneOfType2001 } return nil } func (p *OneOfListProtectionPoliciesApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType401 := new([]ProtectionPolicyProjection) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType401) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType401 == nil || len(*vOneOfType401) == 0 || ((*vOneOfType401)[0].ObjectType_ != nil && "datapolicies.v4.config.ProtectionPolicyProjection" == *((*vOneOfType401)[0].ObjectType_)) { p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new([]ProtectionPolicy) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType2001 == nil || len(*vOneOfType2001) == 0 || ((*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.ProtectionPolicy" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType401 := new([]ProtectionPolicyProjection) if err := json.Unmarshal(b, vOneOfType401); err == nil { if len(*vOneOfType401) == 0 || (vOneOfType401 != nil && (*vOneOfType401)[0].ObjectType_ != nil && "datapolicies.v4.config.ProtectionPolicyProjection" == *((*vOneOfType401)[0].ObjectType_)) { p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new([]ProtectionPolicy) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if len(*vOneOfType2001) == 0 || (vOneOfType2001 != nil && (*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.ProtectionPolicy" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfListProtectionPoliciesApiResponseData")) } func (p *OneOfListProtectionPoliciesApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType401) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfListProtectionPoliciesApiResponseData") } type OneOfListStoragePoliciesApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 []StoragePolicy `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfListStoragePoliciesApiResponseData() *OneOfListStoragePoliciesApiResponseData { p := new(OneOfListStoragePoliciesApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfListStoragePoliciesApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfListStoragePoliciesApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case []StoragePolicy: p.oneOfType2001 = v.([]StoragePolicy) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfListStoragePoliciesApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if "List" == *p.Discriminator { return p.oneOfType2001 } return nil } func (p *OneOfListStoragePoliciesApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["List"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new([]StoragePolicy) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For arrays, verify the array item ObjectType matches if vOneOfType2001 == nil || len(*vOneOfType2001) == 0 || ((*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.StoragePolicy" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new([]StoragePolicy) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if len(*vOneOfType2001) == 0 || (vOneOfType2001 != nil && (*vOneOfType2001)[0].ObjectType_ != nil && "datapolicies.v4.config.StoragePolicy" == *((*vOneOfType2001)[0].ObjectType_)) { p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = "List" if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = "List" return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfListStoragePoliciesApiResponseData")) } func (p *OneOfListStoragePoliciesApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if "List" == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfListStoragePoliciesApiResponseData") } type OneOfUpdateRecoveryPlanApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfUpdateRecoveryPlanApiResponseData() *OneOfUpdateRecoveryPlanApiResponseData { p := new(OneOfUpdateRecoveryPlanApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfUpdateRecoveryPlanApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfUpdateRecoveryPlanApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfUpdateRecoveryPlanApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfUpdateRecoveryPlanApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfUpdateRecoveryPlanApiResponseData")) } func (p *OneOfUpdateRecoveryPlanApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfUpdateRecoveryPlanApiResponseData") } type OneOfCreateNetworkMappingApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfCreateNetworkMappingApiResponseData() *OneOfCreateNetworkMappingApiResponseData { p := new(OneOfCreateNetworkMappingApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfCreateNetworkMappingApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfCreateNetworkMappingApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfCreateNetworkMappingApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfCreateNetworkMappingApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfCreateNetworkMappingApiResponseData")) } func (p *OneOfCreateNetworkMappingApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfCreateNetworkMappingApiResponseData") } type OneOfGetProtectionPolicyApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *ProtectionPolicy `json:"-"` oneOfType401 *ProtectionPolicyProjection `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfGetProtectionPolicyApiResponseData() *OneOfGetProtectionPolicyApiResponseData { p := new(OneOfGetProtectionPolicyApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfGetProtectionPolicyApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfGetProtectionPolicyApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case ProtectionPolicy: if nil == p.oneOfType2001 { p.oneOfType2001 = new(ProtectionPolicy) } *p.oneOfType2001 = v.(ProtectionPolicy) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ case ProtectionPolicyProjection: if nil == p.oneOfType401 { p.oneOfType401 = new(ProtectionPolicyProjection) } *p.oneOfType401 = v.(ProtectionPolicyProjection) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfGetProtectionPolicyApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } if p.oneOfType401 != nil && *p.oneOfType401.ObjectType_ == *p.Discriminator { return *p.oneOfType401 } return nil } func (p *OneOfGetProtectionPolicyApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(ProtectionPolicy) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.ProtectionPolicy" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(ProtectionPolicy) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType401 := new(ProtectionPolicyProjection) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType401) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType401.ObjectType_ != nil && "datapolicies.v4.config.ProtectionPolicyProjection" == *vOneOfType401.ObjectType_ { if nil == p.oneOfType401 { p.oneOfType401 = new(ProtectionPolicyProjection) } *p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(ProtectionPolicy) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.ProtectionPolicy" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(ProtectionPolicy) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } vOneOfType401 := new(ProtectionPolicyProjection) if err := json.Unmarshal(b, vOneOfType401); err == nil { if vOneOfType401.ObjectType_ != nil && "datapolicies.v4.config.ProtectionPolicyProjection" == *vOneOfType401.ObjectType_ { if nil == p.oneOfType401 { p.oneOfType401 = new(ProtectionPolicyProjection) } *p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfGetProtectionPolicyApiResponseData")) } func (p *OneOfGetProtectionPolicyApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } if p.oneOfType401 != nil && *p.oneOfType401.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType401) } return nil, errors.New("No value to marshal for OneOfGetProtectionPolicyApiResponseData") } type OneOfUpdateDataServicesIpMappingApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfUpdateDataServicesIpMappingApiResponseData() *OneOfUpdateDataServicesIpMappingApiResponseData { p := new(OneOfUpdateDataServicesIpMappingApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfUpdateDataServicesIpMappingApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfUpdateDataServicesIpMappingApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfUpdateDataServicesIpMappingApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfUpdateDataServicesIpMappingApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfUpdateDataServicesIpMappingApiResponseData")) } func (p *OneOfUpdateDataServicesIpMappingApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfUpdateDataServicesIpMappingApiResponseData") } type OneOfCreateProtectionPolicyApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfCreateProtectionPolicyApiResponseData() *OneOfCreateProtectionPolicyApiResponseData { p := new(OneOfCreateProtectionPolicyApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfCreateProtectionPolicyApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfCreateProtectionPolicyApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfCreateProtectionPolicyApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfCreateProtectionPolicyApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfCreateProtectionPolicyApiResponseData")) } func (p *OneOfCreateProtectionPolicyApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfCreateProtectionPolicyApiResponseData") } type OneOfGetStoragePolicyApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *StoragePolicy `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfGetStoragePolicyApiResponseData() *OneOfGetStoragePolicyApiResponseData { p := new(OneOfGetStoragePolicyApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfGetStoragePolicyApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfGetStoragePolicyApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case StoragePolicy: if nil == p.oneOfType2001 { p.oneOfType2001 = new(StoragePolicy) } *p.oneOfType2001 = v.(StoragePolicy) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfGetStoragePolicyApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfGetStoragePolicyApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(StoragePolicy) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.StoragePolicy" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(StoragePolicy) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(StoragePolicy) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.StoragePolicy" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(StoragePolicy) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfGetStoragePolicyApiResponseData")) } func (p *OneOfGetStoragePolicyApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfGetStoragePolicyApiResponseData") } type OneOfDeleteRecoverySettingApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfDeleteRecoverySettingApiResponseData() *OneOfDeleteRecoverySettingApiResponseData { p := new(OneOfDeleteRecoverySettingApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfDeleteRecoverySettingApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfDeleteRecoverySettingApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfDeleteRecoverySettingApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfDeleteRecoverySettingApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfDeleteRecoverySettingApiResponseData")) } func (p *OneOfDeleteRecoverySettingApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfDeleteRecoverySettingApiResponseData") } type OneOfGetNetworkMappingApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType401 *NetworkMappingProjection `json:"-"` oneOfType2001 *NetworkMapping `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfGetNetworkMappingApiResponseData() *OneOfGetNetworkMappingApiResponseData { p := new(OneOfGetNetworkMappingApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfGetNetworkMappingApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfGetNetworkMappingApiResponseData is nil")) } switch v.(type) { case NetworkMappingProjection: if nil == p.oneOfType401 { p.oneOfType401 = new(NetworkMappingProjection) } *p.oneOfType401 = v.(NetworkMappingProjection) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ case NetworkMapping: if nil == p.oneOfType2001 { p.oneOfType2001 = new(NetworkMapping) } *p.oneOfType2001 = v.(NetworkMapping) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfGetNetworkMappingApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType401 != nil && *p.oneOfType401.ObjectType_ == *p.Discriminator { return *p.oneOfType401 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } return nil } func (p *OneOfGetNetworkMappingApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType401 := new(NetworkMappingProjection) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType401) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType401.ObjectType_ != nil && "datapolicies.v4.config.NetworkMappingProjection" == *vOneOfType401.ObjectType_ { if nil == p.oneOfType401 { p.oneOfType401 = new(NetworkMappingProjection) } *p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(NetworkMapping) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.NetworkMapping" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(NetworkMapping) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType401 := new(NetworkMappingProjection) if err := json.Unmarshal(b, vOneOfType401); err == nil { if vOneOfType401.ObjectType_ != nil && "datapolicies.v4.config.NetworkMappingProjection" == *vOneOfType401.ObjectType_ { if nil == p.oneOfType401 { p.oneOfType401 = new(NetworkMappingProjection) } *p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ return nil } } vOneOfType2001 := new(NetworkMapping) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.NetworkMapping" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(NetworkMapping) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfGetNetworkMappingApiResponseData")) } func (p *OneOfGetNetworkMappingApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType401 != nil && *p.oneOfType401.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType401) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } return nil, errors.New("No value to marshal for OneOfGetNetworkMappingApiResponseData") } type OneOfDeleteRecoveryStageApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfDeleteRecoveryStageApiResponseData() *OneOfDeleteRecoveryStageApiResponseData { p := new(OneOfDeleteRecoveryStageApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfDeleteRecoveryStageApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfDeleteRecoveryStageApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfDeleteRecoveryStageApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfDeleteRecoveryStageApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfDeleteRecoveryStageApiResponseData")) } func (p *OneOfDeleteRecoveryStageApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfDeleteRecoveryStageApiResponseData") } type OneOfCreateDataServicesIpMappingApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfCreateDataServicesIpMappingApiResponseData() *OneOfCreateDataServicesIpMappingApiResponseData { p := new(OneOfCreateDataServicesIpMappingApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfCreateDataServicesIpMappingApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfCreateDataServicesIpMappingApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfCreateDataServicesIpMappingApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfCreateDataServicesIpMappingApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfCreateDataServicesIpMappingApiResponseData")) } func (p *OneOfCreateDataServicesIpMappingApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfCreateDataServicesIpMappingApiResponseData") } type OneOfGetDataServicesIpMappingApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType401 *DataServicesIpMappingProjection `json:"-"` oneOfType2001 *DataServicesIpMapping `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfGetDataServicesIpMappingApiResponseData() *OneOfGetDataServicesIpMappingApiResponseData { p := new(OneOfGetDataServicesIpMappingApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfGetDataServicesIpMappingApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfGetDataServicesIpMappingApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case DataServicesIpMappingProjection: if nil == p.oneOfType401 { p.oneOfType401 = new(DataServicesIpMappingProjection) } *p.oneOfType401 = v.(DataServicesIpMappingProjection) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ case DataServicesIpMapping: if nil == p.oneOfType2001 { p.oneOfType2001 = new(DataServicesIpMapping) } *p.oneOfType2001 = v.(DataServicesIpMapping) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfGetDataServicesIpMappingApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType401 != nil && *p.oneOfType401.ObjectType_ == *p.Discriminator { return *p.oneOfType401 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfGetDataServicesIpMappingApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType401 := new(DataServicesIpMappingProjection) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType401) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType401.ObjectType_ != nil && "datapolicies.v4.config.DataServicesIpMappingProjection" == *vOneOfType401.ObjectType_ { if nil == p.oneOfType401 { p.oneOfType401 = new(DataServicesIpMappingProjection) } *p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(DataServicesIpMapping) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.DataServicesIpMapping" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(DataServicesIpMapping) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType401 := new(DataServicesIpMappingProjection) if err := json.Unmarshal(b, vOneOfType401); err == nil { if vOneOfType401.ObjectType_ != nil && "datapolicies.v4.config.DataServicesIpMappingProjection" == *vOneOfType401.ObjectType_ { if nil == p.oneOfType401 { p.oneOfType401 = new(DataServicesIpMappingProjection) } *p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ return nil } } vOneOfType2001 := new(DataServicesIpMapping) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.DataServicesIpMapping" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(DataServicesIpMapping) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfGetDataServicesIpMappingApiResponseData")) } func (p *OneOfGetDataServicesIpMappingApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType401 != nil && *p.oneOfType401.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType401) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfGetDataServicesIpMappingApiResponseData") } type OneOfUpdateRecoveryStageApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfUpdateRecoveryStageApiResponseData() *OneOfUpdateRecoveryStageApiResponseData { p := new(OneOfUpdateRecoveryStageApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfUpdateRecoveryStageApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfUpdateRecoveryStageApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfUpdateRecoveryStageApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfUpdateRecoveryStageApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfUpdateRecoveryStageApiResponseData")) } func (p *OneOfUpdateRecoveryStageApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfUpdateRecoveryStageApiResponseData") } type OneOfDeleteStoragePolicyApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType2001 *import2.TaskReference `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfDeleteStoragePolicyApiResponseData() *OneOfDeleteStoragePolicyApiResponseData { p := new(OneOfDeleteStoragePolicyApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfDeleteStoragePolicyApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfDeleteStoragePolicyApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case import2.TaskReference: if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = v.(import2.TaskReference) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfDeleteStoragePolicyApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfDeleteStoragePolicyApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(import2.TaskReference) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType2001 := new(import2.TaskReference) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "prism.v4.config.TaskReference" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(import2.TaskReference) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfDeleteStoragePolicyApiResponseData")) } func (p *OneOfDeleteStoragePolicyApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfDeleteStoragePolicyApiResponseData") } type OneOfGetConsistencyRuleApiResponseData struct { Discriminator *string `json:"-"` ObjectType_ *string `json:"-"` oneOfType400 *import3.ErrorResponse `json:"-"` oneOfType401 *ConsistencyRuleProjection `json:"-"` oneOfType2001 *ConsistencyRule `json:"-"` // Holds data with unknown oneOf types UnknownValue_ interface{} `json:"-"` } func NewOneOfGetConsistencyRuleApiResponseData() *OneOfGetConsistencyRuleApiResponseData { p := new(OneOfGetConsistencyRuleApiResponseData) p.Discriminator = new(string) p.ObjectType_ = new(string) return p } func (p *OneOfGetConsistencyRuleApiResponseData) SetValue(v interface{}) error { if nil == p { return errors.New(fmt.Sprintf("OneOfGetConsistencyRuleApiResponseData is nil")) } switch v.(type) { case import3.ErrorResponse: if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = v.(import3.ErrorResponse) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ case ConsistencyRuleProjection: if nil == p.oneOfType401 { p.oneOfType401 = new(ConsistencyRuleProjection) } *p.oneOfType401 = v.(ConsistencyRuleProjection) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ case ConsistencyRule: if nil == p.oneOfType2001 { p.oneOfType2001 = new(ConsistencyRule) } *p.oneOfType2001 = v.(ConsistencyRule) if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ default: return errors.New(fmt.Sprintf("%T(%v) is not expected type", v, v)) } return nil } func (p *OneOfGetConsistencyRuleApiResponseData) GetValue() interface{} { if p.UnknownValue_ != nil { return p.UnknownValue_ } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return *p.oneOfType400 } if p.oneOfType401 != nil && *p.oneOfType401.ObjectType_ == *p.Discriminator { return *p.oneOfType401 } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return *p.oneOfType2001 } return nil } func (p *OneOfGetConsistencyRuleApiResponseData) UnmarshalJSON(b []byte) error { p.UnknownValue_ = nil // Try to handle nested structure like {"": {"value": {...}}} // This recursively unwraps {"field": {"value": {...}}} patterns for nested oneOf fields var rawMap map[string]interface{} if err := json.Unmarshal(b, &rawMap); err == nil { // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType400 := new(import3.ErrorResponse) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType400) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType401 := new(ConsistencyRuleProjection) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType401) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType401.ObjectType_ != nil && "datapolicies.v4.config.ConsistencyRuleProjection" == *vOneOfType401.ObjectType_ { if nil == p.oneOfType401 { p.oneOfType401 = new(ConsistencyRuleProjection) } *p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ return nil } } } } } // Check if this field name exists in the map (handles nested structure) if nestedMap, ok := rawMap["ObjectType_"].(map[string]interface{}); ok { // Check for "value" wrapper if valueData, ok := nestedMap["value"]; ok { valueJSON, marshalErr := json.Marshal(valueData) if marshalErr == nil { vOneOfType2001 := new(ConsistencyRule) var unmarshalErr error // Unmarshal - if vField has oneOf fields, their UnmarshalJSON will handle nested patterns recursively unmarshalErr = json.Unmarshal(valueJSON, vOneOfType2001) if unmarshalErr == nil { // For struct items, verify the ObjectType matches if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.ConsistencyRule" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(ConsistencyRule) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } } } } } // Fallback: try direct unmarshalling (for non-nested structures) vOneOfType400 := new(import3.ErrorResponse) if err := json.Unmarshal(b, vOneOfType400); err == nil { if vOneOfType400.ObjectType_ != nil && "datapolicies.v4.error.ErrorResponse" == *vOneOfType400.ObjectType_ { if nil == p.oneOfType400 { p.oneOfType400 = new(import3.ErrorResponse) } *p.oneOfType400 = *vOneOfType400 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType400.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType400.ObjectType_ return nil } } vOneOfType401 := new(ConsistencyRuleProjection) if err := json.Unmarshal(b, vOneOfType401); err == nil { if vOneOfType401.ObjectType_ != nil && "datapolicies.v4.config.ConsistencyRuleProjection" == *vOneOfType401.ObjectType_ { if nil == p.oneOfType401 { p.oneOfType401 = new(ConsistencyRuleProjection) } *p.oneOfType401 = *vOneOfType401 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType401.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType401.ObjectType_ return nil } } vOneOfType2001 := new(ConsistencyRule) if err := json.Unmarshal(b, vOneOfType2001); err == nil { if vOneOfType2001.ObjectType_ != nil && "datapolicies.v4.config.ConsistencyRule" == *vOneOfType2001.ObjectType_ { if nil == p.oneOfType2001 { p.oneOfType2001 = new(ConsistencyRule) } *p.oneOfType2001 = *vOneOfType2001 if nil == p.Discriminator { p.Discriminator = new(string) } *p.Discriminator = *p.oneOfType2001.ObjectType_ if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.oneOfType2001.ObjectType_ return nil } } // Store raw when no known variant matched var unknownRaw map[string]interface{} if err := json.Unmarshal(b, &unknownRaw); err == nil { p.UnknownValue_ = unknownRaw if nil == p.Discriminator { p.Discriminator = new(string) } if ot, ok := unknownRaw["$objectType"].(string); ok && ot != "" { *p.Discriminator = ot } else { *p.Discriminator = "UNKNOWN" } if nil == p.ObjectType_ { p.ObjectType_ = new(string) } *p.ObjectType_ = *p.Discriminator return nil } return errors.New(fmt.Sprintf("Unable to unmarshal for OneOfGetConsistencyRuleApiResponseData")) } func (p *OneOfGetConsistencyRuleApiResponseData) MarshalJSON() ([]byte, error) { if p.UnknownValue_ != nil { return json.Marshal(p.UnknownValue_) } if p.oneOfType400 != nil && *p.oneOfType400.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType400) } if p.oneOfType401 != nil && *p.oneOfType401.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType401) } if p.oneOfType2001 != nil && *p.oneOfType2001.ObjectType_ == *p.Discriminator { return json.Marshal(p.oneOfType2001) } return nil, errors.New("No value to marshal for OneOfGetConsistencyRuleApiResponseData") } type FileDetail struct { Path *string `json:"-"` ObjectType_ *string `json:"-"` } func NewFileDetail() *FileDetail { p := new(FileDetail) p.ObjectType_ = new(string) *p.ObjectType_ = "FileDetail" return p }