// Code generated by go-swagger; DO NOT EDIT.

// (c) 2012-2020 by Telnexus LLC
// All rights reserved worldwide.
// Proprietary product; unlicensed use is not allowed

package kazoo_models

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"context"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/strfmt"
	"github.com/go-openapi/swag"
)

// GetAccountResponse get account response
//
// swagger:model GetAccountResponse
type GetAccountResponse struct {

	// auth token
	// Example: eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImM2M2I1NjY5YmE0NTQzZWVmMTE5OTc3ZTUyNDYxYzRlIn0.eyJpc3MiOiJrYXpvbyIsImlkZW50aXR5X3NpZyI6InJUMW5DNnNOOHNKQWp4blBSSk1LVE5Ed1ZEQWZwek9sSFBnb0FYTHgtQU0iLCJhY2NvdW50X2lkIjoiYTY2ZjJiN2E0MDk0NGI3NDRkY2M2M2NhNmYxMGY0N2EiLCJvd25lcl9pZCI6IjUwOTE2MWZmMmE1NzZiZDZhYmU1YjhjNzVmNmIxNWYwIiwibWV0aG9kIjoiY2JfdXNlcl9hdXRoIiwiZXhwIjoxNTg4ODA3NjcyfQ.rsxUwAef3JnHzTc4eckxIx_RToGbNsKr3WVUoVDEPQ7slKLxhpfDTrNqXQ_kou-1646Z539YQCQGRsB5One4BfEDAfhAmH63d6jKwEU49yQUiZCBn8tbuzN4iiZmYn6z8wmqUQHO2KA3fo6IKrjggs3t1EK8iG05se4ltS21ZVQ-C0HVvvENoERu9iKEcM2SeKhl9Ucl3cqQpWRKBN9BEvTKpuXqM_Bkf2FiczQ3TJQ2SS0YJTYjoIKnOLHfM4H59ZcPwnTh0S3zplJ8e6dQv6t020x0gVYdA_U9EseIGhNQTtMEAztwleZJwdpBh6kiDxJb9-l4ENX4kFtvxsH4QQ
	AuthToken string `json:"auth_token,omitempty"`

	// data
	Data *GetAccountResponseData `json:"data,omitempty"`

	// node
	// Example: dqZFtHthbelyE8MI6vU-LA
	Node string `json:"node,omitempty"`

	// request id
	// Example: 1bea6f4e37f65627452f9798d8398385
	RequestID string `json:"request_id,omitempty"`

	// revision
	// Example: 270-8664316349384947d416dc00285fb532
	Revision string `json:"revision,omitempty"`

	// status
	// Example: success
	Status string `json:"status,omitempty"`

	// timestamp
	// Example: 2020-05-06T22:42:58Z
	Timestamp string `json:"timestamp,omitempty"`

	// version
	// Example: 4.3.103
	Version string `json:"version,omitempty"`
}

// Validate validates this get account response
func (m *GetAccountResponse) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateData(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *GetAccountResponse) validateData(formats strfmt.Registry) error {
	if swag.IsZero(m.Data) { // not required
		return nil
	}

	if m.Data != nil {
		if err := m.Data.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this get account response based on the context it is used
func (m *GetAccountResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateData(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *GetAccountResponse) contextValidateData(ctx context.Context, formats strfmt.Registry) error {

	if m.Data != nil {
		if err := m.Data.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponse) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponse) UnmarshalBinary(b []byte) error {
	var res GetAccountResponse
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseData get account response data
//
// swagger:model GetAccountResponseData
type GetAccountResponseData struct {

	// available apps
	// Example: ["voip","cluster","userportal","accounts","developer","pbxs","numbers"]
	AvailableApps []string `json:"available_apps"`

	// billing id
	// Example: a66f2b7a40944b744dcc63ca6f10f47a
	BillingID string `json:"billing_id,omitempty"`

	// billing mode
	// Example: manual
	BillingMode string `json:"billing_mode,omitempty"`

	// call restriction
	CallRestriction *GetAccountResponseDataCallRestriction `json:"call_restriction,omitempty"`

	// caller id
	CallerID *GetAccountResponseDataCallerID `json:"caller_id,omitempty"`

	// contact
	Contact *GetAccountResponseDataContact `json:"contact,omitempty"`

	// created
	// Example: 63552627756
	Created int64 `json:"created,omitempty"`

	// descendants count
	// Example: 48
	DescendantsCount float64 `json:"descendants_count,omitempty"`

	// enabled
	// Example: true
	Enabled bool `json:"enabled,omitempty"`

	// format from uri
	// Example: false
	FormatFromURI bool `json:"format_from_uri,omitempty"`

	// id
	// Example: a66f2b7a40944b744dcc63ca6f10f47a
	ID string `json:"id,omitempty"`

	// is reseller
	// Example: false
	IsReseller bool `json:"is_reseller,omitempty"`

	// language
	// Example: en-us
	Language string `json:"language,omitempty"`

	// media
	Media *GetAccountResponseDataMedia `json:"media,omitempty"`

	// name
	// Example: Telnexus Direct
	Name string `json:"name,omitempty"`

	// notification preference
	// Example: teletype
	NotificationPreference string `json:"notification_preference,omitempty"`

	// notifications
	Notifications *GetAccountResponseDataNotifications `json:"notifications,omitempty"`

	// provision
	Provision *GetAccountResponseDataProvision `json:"provision,omitempty"`

	// realm
	// Example: f5b70e.s.zswitch.net
	Realm string `json:"realm,omitempty"`

	// reseller id
	// Example: 33776f3f94eb642c81e199cf5f1059ae
	ResellerID string `json:"reseller_id,omitempty"`

	// superduper admin
	// Example: false
	SuperduperAdmin bool `json:"superduper_admin,omitempty"`

	// timezone
	// Example: America/Los_Angeles
	Timezone string `json:"timezone,omitempty"`

	// ui metadata
	UIMetadata *GetAccountResponseDataUIMetadata `json:"ui_metadata,omitempty"`

	// ui restrictions
	UIRestrictions *GetAccountResponseDataUIRestrictions `json:"ui_restrictions,omitempty"`

	// wnm allow additions
	// Example: false
	WnmAllowAdditions bool `json:"wnm_allow_additions,omitempty"`
}

// Validate validates this get account response data
func (m *GetAccountResponseData) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateCallRestriction(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateCallerID(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateContact(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateMedia(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateNotifications(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateProvision(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateUIMetadata(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateUIRestrictions(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *GetAccountResponseData) validateCallRestriction(formats strfmt.Registry) error {
	if swag.IsZero(m.CallRestriction) { // not required
		return nil
	}

	if m.CallRestriction != nil {
		if err := m.CallRestriction.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseData) validateCallerID(formats strfmt.Registry) error {
	if swag.IsZero(m.CallerID) { // not required
		return nil
	}

	if m.CallerID != nil {
		if err := m.CallerID.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "caller_id")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseData) validateContact(formats strfmt.Registry) error {
	if swag.IsZero(m.Contact) { // not required
		return nil
	}

	if m.Contact != nil {
		if err := m.Contact.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "contact")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseData) validateMedia(formats strfmt.Registry) error {
	if swag.IsZero(m.Media) { // not required
		return nil
	}

	if m.Media != nil {
		if err := m.Media.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "media")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseData) validateNotifications(formats strfmt.Registry) error {
	if swag.IsZero(m.Notifications) { // not required
		return nil
	}

	if m.Notifications != nil {
		if err := m.Notifications.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "notifications")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseData) validateProvision(formats strfmt.Registry) error {
	if swag.IsZero(m.Provision) { // not required
		return nil
	}

	if m.Provision != nil {
		if err := m.Provision.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "provision")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseData) validateUIMetadata(formats strfmt.Registry) error {
	if swag.IsZero(m.UIMetadata) { // not required
		return nil
	}

	if m.UIMetadata != nil {
		if err := m.UIMetadata.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_metadata")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseData) validateUIRestrictions(formats strfmt.Registry) error {
	if swag.IsZero(m.UIRestrictions) { // not required
		return nil
	}

	if m.UIRestrictions != nil {
		if err := m.UIRestrictions.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this get account response data based on the context it is used
func (m *GetAccountResponseData) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateCallRestriction(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateCallerID(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateContact(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateMedia(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateNotifications(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateProvision(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateUIMetadata(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateUIRestrictions(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *GetAccountResponseData) contextValidateCallRestriction(ctx context.Context, formats strfmt.Registry) error {

	if m.CallRestriction != nil {
		if err := m.CallRestriction.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseData) contextValidateCallerID(ctx context.Context, formats strfmt.Registry) error {

	if m.CallerID != nil {
		if err := m.CallerID.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "caller_id")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseData) contextValidateContact(ctx context.Context, formats strfmt.Registry) error {

	if m.Contact != nil {
		if err := m.Contact.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "contact")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseData) contextValidateMedia(ctx context.Context, formats strfmt.Registry) error {

	if m.Media != nil {
		if err := m.Media.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "media")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseData) contextValidateNotifications(ctx context.Context, formats strfmt.Registry) error {

	if m.Notifications != nil {
		if err := m.Notifications.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "notifications")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseData) contextValidateProvision(ctx context.Context, formats strfmt.Registry) error {

	if m.Provision != nil {
		if err := m.Provision.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "provision")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseData) contextValidateUIMetadata(ctx context.Context, formats strfmt.Registry) error {

	if m.UIMetadata != nil {
		if err := m.UIMetadata.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_metadata")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseData) contextValidateUIRestrictions(ctx context.Context, formats strfmt.Registry) error {

	if m.UIRestrictions != nil {
		if err := m.UIRestrictions.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseData) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseData) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseData
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataCallRestriction get account response data call restriction
//
// swagger:model GetAccountResponseDataCallRestriction
type GetAccountResponseDataCallRestriction struct {

	// caribbean
	Caribbean *GetAccountResponseDataCallRestrictionCaribbean `json:"caribbean,omitempty"`

	// did us
	DidUs *GetAccountResponseDataCallRestrictionDidUs `json:"did_us,omitempty"`

	// directory
	Directory *GetAccountResponseDataCallRestrictionDirectory `json:"directory,omitempty"`

	// emergency
	Emergency *GetAccountResponseDataCallRestrictionEmergency `json:"emergency,omitempty"`

	// international
	International *GetAccountResponseDataCallRestrictionInternational `json:"international,omitempty"`

	// toll us
	TollUs *GetAccountResponseDataCallRestrictionTollUs `json:"toll_us,omitempty"`

	// tollfree us
	TollfreeUs *GetAccountResponseDataCallRestrictionTollfreeUs `json:"tollfree_us,omitempty"`

	// unknown
	Unknown *GetAccountResponseDataCallRestrictionUnknown `json:"unknown,omitempty"`
}

// Validate validates this get account response data call restriction
func (m *GetAccountResponseDataCallRestriction) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateCaribbean(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateDidUs(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateDirectory(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateEmergency(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateInternational(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateTollUs(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateTollfreeUs(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateUnknown(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *GetAccountResponseDataCallRestriction) validateCaribbean(formats strfmt.Registry) error {
	if swag.IsZero(m.Caribbean) { // not required
		return nil
	}

	if m.Caribbean != nil {
		if err := m.Caribbean.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction" + "." + "caribbean")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataCallRestriction) validateDidUs(formats strfmt.Registry) error {
	if swag.IsZero(m.DidUs) { // not required
		return nil
	}

	if m.DidUs != nil {
		if err := m.DidUs.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction" + "." + "did_us")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataCallRestriction) validateDirectory(formats strfmt.Registry) error {
	if swag.IsZero(m.Directory) { // not required
		return nil
	}

	if m.Directory != nil {
		if err := m.Directory.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction" + "." + "directory")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataCallRestriction) validateEmergency(formats strfmt.Registry) error {
	if swag.IsZero(m.Emergency) { // not required
		return nil
	}

	if m.Emergency != nil {
		if err := m.Emergency.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction" + "." + "emergency")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataCallRestriction) validateInternational(formats strfmt.Registry) error {
	if swag.IsZero(m.International) { // not required
		return nil
	}

	if m.International != nil {
		if err := m.International.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction" + "." + "international")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataCallRestriction) validateTollUs(formats strfmt.Registry) error {
	if swag.IsZero(m.TollUs) { // not required
		return nil
	}

	if m.TollUs != nil {
		if err := m.TollUs.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction" + "." + "toll_us")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataCallRestriction) validateTollfreeUs(formats strfmt.Registry) error {
	if swag.IsZero(m.TollfreeUs) { // not required
		return nil
	}

	if m.TollfreeUs != nil {
		if err := m.TollfreeUs.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction" + "." + "tollfree_us")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataCallRestriction) validateUnknown(formats strfmt.Registry) error {
	if swag.IsZero(m.Unknown) { // not required
		return nil
	}

	if m.Unknown != nil {
		if err := m.Unknown.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction" + "." + "unknown")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this get account response data call restriction based on the context it is used
func (m *GetAccountResponseDataCallRestriction) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateCaribbean(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateDidUs(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateDirectory(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateEmergency(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateInternational(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateTollUs(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateTollfreeUs(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateUnknown(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *GetAccountResponseDataCallRestriction) contextValidateCaribbean(ctx context.Context, formats strfmt.Registry) error {

	if m.Caribbean != nil {
		if err := m.Caribbean.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction" + "." + "caribbean")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataCallRestriction) contextValidateDidUs(ctx context.Context, formats strfmt.Registry) error {

	if m.DidUs != nil {
		if err := m.DidUs.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction" + "." + "did_us")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataCallRestriction) contextValidateDirectory(ctx context.Context, formats strfmt.Registry) error {

	if m.Directory != nil {
		if err := m.Directory.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction" + "." + "directory")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataCallRestriction) contextValidateEmergency(ctx context.Context, formats strfmt.Registry) error {

	if m.Emergency != nil {
		if err := m.Emergency.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction" + "." + "emergency")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataCallRestriction) contextValidateInternational(ctx context.Context, formats strfmt.Registry) error {

	if m.International != nil {
		if err := m.International.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction" + "." + "international")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataCallRestriction) contextValidateTollUs(ctx context.Context, formats strfmt.Registry) error {

	if m.TollUs != nil {
		if err := m.TollUs.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction" + "." + "toll_us")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataCallRestriction) contextValidateTollfreeUs(ctx context.Context, formats strfmt.Registry) error {

	if m.TollfreeUs != nil {
		if err := m.TollfreeUs.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction" + "." + "tollfree_us")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataCallRestriction) contextValidateUnknown(ctx context.Context, formats strfmt.Registry) error {

	if m.Unknown != nil {
		if err := m.Unknown.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "call_restriction" + "." + "unknown")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestriction) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestriction) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataCallRestriction
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataCallRestrictionCaribbean get account response data call restriction caribbean
//
// swagger:model GetAccountResponseDataCallRestrictionCaribbean
type GetAccountResponseDataCallRestrictionCaribbean struct {

	// action
	// Example: inherit
	Action string `json:"action,omitempty"`
}

// Validate validates this get account response data call restriction caribbean
func (m *GetAccountResponseDataCallRestrictionCaribbean) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data call restriction caribbean based on context it is used
func (m *GetAccountResponseDataCallRestrictionCaribbean) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestrictionCaribbean) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestrictionCaribbean) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataCallRestrictionCaribbean
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataCallRestrictionDidUs get account response data call restriction did us
//
// swagger:model GetAccountResponseDataCallRestrictionDidUs
type GetAccountResponseDataCallRestrictionDidUs struct {

	// action
	// Example: inherit
	Action string `json:"action,omitempty"`
}

// Validate validates this get account response data call restriction did us
func (m *GetAccountResponseDataCallRestrictionDidUs) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data call restriction did us based on context it is used
func (m *GetAccountResponseDataCallRestrictionDidUs) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestrictionDidUs) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestrictionDidUs) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataCallRestrictionDidUs
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataCallRestrictionDirectory get account response data call restriction directory
//
// swagger:model GetAccountResponseDataCallRestrictionDirectory
type GetAccountResponseDataCallRestrictionDirectory struct {

	// action
	// Example: inherit
	Action string `json:"action,omitempty"`
}

// Validate validates this get account response data call restriction directory
func (m *GetAccountResponseDataCallRestrictionDirectory) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data call restriction directory based on context it is used
func (m *GetAccountResponseDataCallRestrictionDirectory) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestrictionDirectory) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestrictionDirectory) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataCallRestrictionDirectory
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataCallRestrictionEmergency get account response data call restriction emergency
//
// swagger:model GetAccountResponseDataCallRestrictionEmergency
type GetAccountResponseDataCallRestrictionEmergency struct {

	// action
	// Example: inherit
	Action string `json:"action,omitempty"`
}

// Validate validates this get account response data call restriction emergency
func (m *GetAccountResponseDataCallRestrictionEmergency) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data call restriction emergency based on context it is used
func (m *GetAccountResponseDataCallRestrictionEmergency) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestrictionEmergency) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestrictionEmergency) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataCallRestrictionEmergency
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataCallRestrictionInternational get account response data call restriction international
//
// swagger:model GetAccountResponseDataCallRestrictionInternational
type GetAccountResponseDataCallRestrictionInternational struct {

	// action
	// Example: inherit
	Action string `json:"action,omitempty"`
}

// Validate validates this get account response data call restriction international
func (m *GetAccountResponseDataCallRestrictionInternational) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data call restriction international based on context it is used
func (m *GetAccountResponseDataCallRestrictionInternational) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestrictionInternational) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestrictionInternational) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataCallRestrictionInternational
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataCallRestrictionTollUs get account response data call restriction toll us
//
// swagger:model GetAccountResponseDataCallRestrictionTollUs
type GetAccountResponseDataCallRestrictionTollUs struct {

	// action
	// Example: inherit
	Action string `json:"action,omitempty"`
}

// Validate validates this get account response data call restriction toll us
func (m *GetAccountResponseDataCallRestrictionTollUs) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data call restriction toll us based on context it is used
func (m *GetAccountResponseDataCallRestrictionTollUs) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestrictionTollUs) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestrictionTollUs) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataCallRestrictionTollUs
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataCallRestrictionTollfreeUs get account response data call restriction tollfree us
//
// swagger:model GetAccountResponseDataCallRestrictionTollfreeUs
type GetAccountResponseDataCallRestrictionTollfreeUs struct {

	// action
	// Example: inherit
	Action string `json:"action,omitempty"`
}

// Validate validates this get account response data call restriction tollfree us
func (m *GetAccountResponseDataCallRestrictionTollfreeUs) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data call restriction tollfree us based on context it is used
func (m *GetAccountResponseDataCallRestrictionTollfreeUs) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestrictionTollfreeUs) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestrictionTollfreeUs) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataCallRestrictionTollfreeUs
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataCallRestrictionUnknown get account response data call restriction unknown
//
// swagger:model GetAccountResponseDataCallRestrictionUnknown
type GetAccountResponseDataCallRestrictionUnknown struct {

	// action
	// Example: inherit
	Action string `json:"action,omitempty"`
}

// Validate validates this get account response data call restriction unknown
func (m *GetAccountResponseDataCallRestrictionUnknown) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data call restriction unknown based on context it is used
func (m *GetAccountResponseDataCallRestrictionUnknown) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestrictionUnknown) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataCallRestrictionUnknown) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataCallRestrictionUnknown
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataCallerID get account response data caller ID
//
// swagger:model GetAccountResponseDataCallerID
type GetAccountResponseDataCallerID struct {

	// emergency
	Emergency *GetAccountResponseDataCallerIDEmergency `json:"emergency,omitempty"`

	// external
	External *GetAccountResponseDataCallerIDExternal `json:"external,omitempty"`
}

// Validate validates this get account response data caller ID
func (m *GetAccountResponseDataCallerID) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateEmergency(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateExternal(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *GetAccountResponseDataCallerID) validateEmergency(formats strfmt.Registry) error {
	if swag.IsZero(m.Emergency) { // not required
		return nil
	}

	if m.Emergency != nil {
		if err := m.Emergency.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "caller_id" + "." + "emergency")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataCallerID) validateExternal(formats strfmt.Registry) error {
	if swag.IsZero(m.External) { // not required
		return nil
	}

	if m.External != nil {
		if err := m.External.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "caller_id" + "." + "external")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this get account response data caller ID based on the context it is used
func (m *GetAccountResponseDataCallerID) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateEmergency(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateExternal(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *GetAccountResponseDataCallerID) contextValidateEmergency(ctx context.Context, formats strfmt.Registry) error {

	if m.Emergency != nil {
		if err := m.Emergency.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "caller_id" + "." + "emergency")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataCallerID) contextValidateExternal(ctx context.Context, formats strfmt.Registry) error {

	if m.External != nil {
		if err := m.External.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "caller_id" + "." + "external")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataCallerID) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataCallerID) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataCallerID
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataCallerIDEmergency get account response data caller ID emergency
//
// swagger:model GetAccountResponseDataCallerIDEmergency
type GetAccountResponseDataCallerIDEmergency struct {

	// name
	// Example: Telnexus
	Name string `json:"name,omitempty"`

	// number
	// Example: +15109911114
	Number string `json:"number,omitempty"`
}

// Validate validates this get account response data caller ID emergency
func (m *GetAccountResponseDataCallerIDEmergency) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data caller ID emergency based on context it is used
func (m *GetAccountResponseDataCallerIDEmergency) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataCallerIDEmergency) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataCallerIDEmergency) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataCallerIDEmergency
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataCallerIDExternal get account response data caller ID external
//
// swagger:model GetAccountResponseDataCallerIDExternal
type GetAccountResponseDataCallerIDExternal struct {

	// name
	// Example: Telnexus
	Name string `json:"name,omitempty"`

	// number
	// Example: +15109911114
	Number string `json:"number,omitempty"`
}

// Validate validates this get account response data caller ID external
func (m *GetAccountResponseDataCallerIDExternal) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data caller ID external based on context it is used
func (m *GetAccountResponseDataCallerIDExternal) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataCallerIDExternal) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataCallerIDExternal) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataCallerIDExternal
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataContact get account response data contact
//
// swagger:model GetAccountResponseDataContact
type GetAccountResponseDataContact struct {

	// billing
	Billing *GetAccountResponseDataContactBilling `json:"billing,omitempty"`

	// technical
	Technical *GetAccountResponseDataContactTechnical `json:"technical,omitempty"`
}

// Validate validates this get account response data contact
func (m *GetAccountResponseDataContact) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateBilling(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateTechnical(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *GetAccountResponseDataContact) validateBilling(formats strfmt.Registry) error {
	if swag.IsZero(m.Billing) { // not required
		return nil
	}

	if m.Billing != nil {
		if err := m.Billing.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "contact" + "." + "billing")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataContact) validateTechnical(formats strfmt.Registry) error {
	if swag.IsZero(m.Technical) { // not required
		return nil
	}

	if m.Technical != nil {
		if err := m.Technical.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "contact" + "." + "technical")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this get account response data contact based on the context it is used
func (m *GetAccountResponseDataContact) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateBilling(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateTechnical(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *GetAccountResponseDataContact) contextValidateBilling(ctx context.Context, formats strfmt.Registry) error {

	if m.Billing != nil {
		if err := m.Billing.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "contact" + "." + "billing")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataContact) contextValidateTechnical(ctx context.Context, formats strfmt.Registry) error {

	if m.Technical != nil {
		if err := m.Technical.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "contact" + "." + "technical")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataContact) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataContact) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataContact
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataContactBilling get account response data contact billing
//
// swagger:model GetAccountResponseDataContactBilling
type GetAccountResponseDataContactBilling struct {

	// email
	// Example: noc@telnexus.com
	Email string `json:"email,omitempty"`

	// name
	Name string `json:"name,omitempty"`

	// number
	// Example: 5108597000
	Number string `json:"number,omitempty"`
}

// Validate validates this get account response data contact billing
func (m *GetAccountResponseDataContactBilling) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data contact billing based on context it is used
func (m *GetAccountResponseDataContactBilling) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataContactBilling) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataContactBilling) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataContactBilling
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataContactTechnical get account response data contact technical
//
// swagger:model GetAccountResponseDataContactTechnical
type GetAccountResponseDataContactTechnical struct {

	// email
	// Example: noc@telnexus.com
	Email string `json:"email,omitempty"`

	// number
	// Example: 5108497000
	Number string `json:"number,omitempty"`
}

// Validate validates this get account response data contact technical
func (m *GetAccountResponseDataContactTechnical) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data contact technical based on context it is used
func (m *GetAccountResponseDataContactTechnical) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataContactTechnical) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataContactTechnical) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataContactTechnical
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataMedia get account response data media
//
// swagger:model GetAccountResponseDataMedia
type GetAccountResponseDataMedia struct {

	// bypass media
	// Example: auto
	BypassMedia string `json:"bypass_media,omitempty"`
}

// Validate validates this get account response data media
func (m *GetAccountResponseDataMedia) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data media based on context it is used
func (m *GetAccountResponseDataMedia) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataMedia) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataMedia) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataMedia
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataNotifications get account response data notifications
//
// swagger:model GetAccountResponseDataNotifications
type GetAccountResponseDataNotifications struct {

	// fax to email
	FaxToEmail *GetAccountResponseDataNotificationsFaxToEmail `json:"fax_to_email,omitempty"`

	// low balance
	LowBalance *GetAccountResponseDataNotificationsLowBalance `json:"low_balance,omitempty"`

	// voicemail to email
	VoicemailToEmail *GetAccountResponseDataNotificationsVoicemailToEmail `json:"voicemail_to_email,omitempty"`
}

// Validate validates this get account response data notifications
func (m *GetAccountResponseDataNotifications) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateFaxToEmail(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateLowBalance(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateVoicemailToEmail(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *GetAccountResponseDataNotifications) validateFaxToEmail(formats strfmt.Registry) error {
	if swag.IsZero(m.FaxToEmail) { // not required
		return nil
	}

	if m.FaxToEmail != nil {
		if err := m.FaxToEmail.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "notifications" + "." + "fax_to_email")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataNotifications) validateLowBalance(formats strfmt.Registry) error {
	if swag.IsZero(m.LowBalance) { // not required
		return nil
	}

	if m.LowBalance != nil {
		if err := m.LowBalance.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "notifications" + "." + "low_balance")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataNotifications) validateVoicemailToEmail(formats strfmt.Registry) error {
	if swag.IsZero(m.VoicemailToEmail) { // not required
		return nil
	}

	if m.VoicemailToEmail != nil {
		if err := m.VoicemailToEmail.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "notifications" + "." + "voicemail_to_email")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this get account response data notifications based on the context it is used
func (m *GetAccountResponseDataNotifications) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateFaxToEmail(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateLowBalance(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateVoicemailToEmail(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *GetAccountResponseDataNotifications) contextValidateFaxToEmail(ctx context.Context, formats strfmt.Registry) error {

	if m.FaxToEmail != nil {
		if err := m.FaxToEmail.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "notifications" + "." + "fax_to_email")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataNotifications) contextValidateLowBalance(ctx context.Context, formats strfmt.Registry) error {

	if m.LowBalance != nil {
		if err := m.LowBalance.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "notifications" + "." + "low_balance")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataNotifications) contextValidateVoicemailToEmail(ctx context.Context, formats strfmt.Registry) error {

	if m.VoicemailToEmail != nil {
		if err := m.VoicemailToEmail.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "notifications" + "." + "voicemail_to_email")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataNotifications) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataNotifications) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataNotifications
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataNotificationsFaxToEmail get account response data notifications fax to email
//
// swagger:model GetAccountResponseDataNotificationsFaxToEmail
type GetAccountResponseDataNotificationsFaxToEmail struct {

	// service name
	// Example: support@telnexus.com
	ServiceName string `json:"service_name,omitempty"`

	// service provider
	// Example: support@telnexus.com
	ServiceProvider string `json:"service_provider,omitempty"`

	// service url
	// Example: telnexus.com
	ServiceURL string `json:"service_url,omitempty"`

	// support email
	// Example: support@telnexus.com
	SupportEmail string `json:"support_email,omitempty"`

	// support number
	// Example: 510-991-1114
	SupportNumber string `json:"support_number,omitempty"`
}

// Validate validates this get account response data notifications fax to email
func (m *GetAccountResponseDataNotificationsFaxToEmail) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data notifications fax to email based on context it is used
func (m *GetAccountResponseDataNotificationsFaxToEmail) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataNotificationsFaxToEmail) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataNotificationsFaxToEmail) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataNotificationsFaxToEmail
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataNotificationsLowBalance get account response data notifications low balance
//
// swagger:model GetAccountResponseDataNotificationsLowBalance
type GetAccountResponseDataNotificationsLowBalance struct {

	// sent low balance
	// Example: false
	SentLowBalance bool `json:"sent_low_balance,omitempty"`
}

// Validate validates this get account response data notifications low balance
func (m *GetAccountResponseDataNotificationsLowBalance) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data notifications low balance based on context it is used
func (m *GetAccountResponseDataNotificationsLowBalance) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataNotificationsLowBalance) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataNotificationsLowBalance) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataNotificationsLowBalance
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataNotificationsVoicemailToEmail get account response data notifications voicemail to email
//
// swagger:model GetAccountResponseDataNotificationsVoicemailToEmail
type GetAccountResponseDataNotificationsVoicemailToEmail struct {

	// service name
	// Example: support@telnexus.com
	ServiceName string `json:"service_name,omitempty"`

	// service provider
	// Example: support@telnexus.com
	ServiceProvider string `json:"service_provider,omitempty"`

	// service url
	// Example: telnexus.com
	ServiceURL string `json:"service_url,omitempty"`

	// support email
	// Example: support@telnexus.com
	SupportEmail string `json:"support_email,omitempty"`

	// support number
	// Example: 510-991-1114
	SupportNumber string `json:"support_number,omitempty"`
}

// Validate validates this get account response data notifications voicemail to email
func (m *GetAccountResponseDataNotificationsVoicemailToEmail) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data notifications voicemail to email based on context it is used
func (m *GetAccountResponseDataNotificationsVoicemailToEmail) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataNotificationsVoicemailToEmail) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataNotificationsVoicemailToEmail) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataNotificationsVoicemailToEmail
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataProvision get account response data provision
//
// swagger:model GetAccountResponseDataProvision
type GetAccountResponseDataProvision struct {

	// admin password
	AdminPassword string `json:"admin_password,omitempty"`
}

// Validate validates this get account response data provision
func (m *GetAccountResponseDataProvision) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data provision based on context it is used
func (m *GetAccountResponseDataProvision) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataProvision) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataProvision) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataProvision
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataUIMetadata get account response data UI metadata
//
// swagger:model GetAccountResponseDataUIMetadata
type GetAccountResponseDataUIMetadata struct {

	// origin
	// Example: accounts
	Origin string `json:"origin,omitempty"`

	// ui
	// Example: monster-ui
	UI string `json:"ui,omitempty"`

	// version
	// Example: 4.1-56
	Version string `json:"version,omitempty"`
}

// Validate validates this get account response data UI metadata
func (m *GetAccountResponseDataUIMetadata) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data UI metadata based on context it is used
func (m *GetAccountResponseDataUIMetadata) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataUIMetadata) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataUIMetadata) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataUIMetadata
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataUIRestrictions get account response data UI restrictions
//
// swagger:model GetAccountResponseDataUIRestrictions
type GetAccountResponseDataUIRestrictions struct {

	// myaccount
	Myaccount *GetAccountResponseDataUIRestrictionsMyaccount `json:"myaccount,omitempty"`
}

// Validate validates this get account response data UI restrictions
func (m *GetAccountResponseDataUIRestrictions) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateMyaccount(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *GetAccountResponseDataUIRestrictions) validateMyaccount(formats strfmt.Registry) error {
	if swag.IsZero(m.Myaccount) { // not required
		return nil
	}

	if m.Myaccount != nil {
		if err := m.Myaccount.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this get account response data UI restrictions based on the context it is used
func (m *GetAccountResponseDataUIRestrictions) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateMyaccount(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *GetAccountResponseDataUIRestrictions) contextValidateMyaccount(ctx context.Context, formats strfmt.Registry) error {

	if m.Myaccount != nil {
		if err := m.Myaccount.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictions) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictions) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataUIRestrictions
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataUIRestrictionsMyaccount get account response data UI restrictions myaccount
//
// swagger:model GetAccountResponseDataUIRestrictionsMyaccount
type GetAccountResponseDataUIRestrictionsMyaccount struct {

	// account
	Account *GetAccountResponseDataUIRestrictionsMyaccountAccount `json:"account,omitempty"`

	// balance
	Balance *GetAccountResponseDataUIRestrictionsMyaccountBalance `json:"balance,omitempty"`

	// billing
	Billing *GetAccountResponseDataUIRestrictionsMyaccountBilling `json:"billing,omitempty"`

	// error tracker
	ErrorTracker *GetAccountResponseDataUIRestrictionsMyaccountErrorTracker `json:"errorTracker,omitempty"`

	// inbound
	Inbound *GetAccountResponseDataUIRestrictionsMyaccountInbound `json:"inbound,omitempty"`

	// outbound
	Outbound *GetAccountResponseDataUIRestrictionsMyaccountOutbound `json:"outbound,omitempty"`

	// service plan
	ServicePlan *GetAccountResponseDataUIRestrictionsMyaccountServicePlan `json:"service_plan,omitempty"`

	// transactions
	Transactions *GetAccountResponseDataUIRestrictionsMyaccountTransactions `json:"transactions,omitempty"`

	// twoway
	Twoway *GetAccountResponseDataUIRestrictionsMyaccountTwoway `json:"twoway,omitempty"`

	// user
	User *GetAccountResponseDataUIRestrictionsMyaccountUser `json:"user,omitempty"`
}

// Validate validates this get account response data UI restrictions myaccount
func (m *GetAccountResponseDataUIRestrictionsMyaccount) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateAccount(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateBalance(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateBilling(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateErrorTracker(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateInbound(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateOutbound(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateServicePlan(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateTransactions(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateTwoway(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateUser(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) validateAccount(formats strfmt.Registry) error {
	if swag.IsZero(m.Account) { // not required
		return nil
	}

	if m.Account != nil {
		if err := m.Account.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "account")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) validateBalance(formats strfmt.Registry) error {
	if swag.IsZero(m.Balance) { // not required
		return nil
	}

	if m.Balance != nil {
		if err := m.Balance.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "balance")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) validateBilling(formats strfmt.Registry) error {
	if swag.IsZero(m.Billing) { // not required
		return nil
	}

	if m.Billing != nil {
		if err := m.Billing.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "billing")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) validateErrorTracker(formats strfmt.Registry) error {
	if swag.IsZero(m.ErrorTracker) { // not required
		return nil
	}

	if m.ErrorTracker != nil {
		if err := m.ErrorTracker.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "errorTracker")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) validateInbound(formats strfmt.Registry) error {
	if swag.IsZero(m.Inbound) { // not required
		return nil
	}

	if m.Inbound != nil {
		if err := m.Inbound.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "inbound")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) validateOutbound(formats strfmt.Registry) error {
	if swag.IsZero(m.Outbound) { // not required
		return nil
	}

	if m.Outbound != nil {
		if err := m.Outbound.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "outbound")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) validateServicePlan(formats strfmt.Registry) error {
	if swag.IsZero(m.ServicePlan) { // not required
		return nil
	}

	if m.ServicePlan != nil {
		if err := m.ServicePlan.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "service_plan")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) validateTransactions(formats strfmt.Registry) error {
	if swag.IsZero(m.Transactions) { // not required
		return nil
	}

	if m.Transactions != nil {
		if err := m.Transactions.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "transactions")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) validateTwoway(formats strfmt.Registry) error {
	if swag.IsZero(m.Twoway) { // not required
		return nil
	}

	if m.Twoway != nil {
		if err := m.Twoway.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "twoway")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) validateUser(formats strfmt.Registry) error {
	if swag.IsZero(m.User) { // not required
		return nil
	}

	if m.User != nil {
		if err := m.User.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "user")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this get account response data UI restrictions myaccount based on the context it is used
func (m *GetAccountResponseDataUIRestrictionsMyaccount) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateAccount(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateBalance(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateBilling(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateErrorTracker(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateInbound(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateOutbound(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateServicePlan(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateTransactions(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateTwoway(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateUser(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) contextValidateAccount(ctx context.Context, formats strfmt.Registry) error {

	if m.Account != nil {
		if err := m.Account.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "account")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) contextValidateBalance(ctx context.Context, formats strfmt.Registry) error {

	if m.Balance != nil {
		if err := m.Balance.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "balance")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) contextValidateBilling(ctx context.Context, formats strfmt.Registry) error {

	if m.Billing != nil {
		if err := m.Billing.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "billing")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) contextValidateErrorTracker(ctx context.Context, formats strfmt.Registry) error {

	if m.ErrorTracker != nil {
		if err := m.ErrorTracker.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "errorTracker")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) contextValidateInbound(ctx context.Context, formats strfmt.Registry) error {

	if m.Inbound != nil {
		if err := m.Inbound.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "inbound")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) contextValidateOutbound(ctx context.Context, formats strfmt.Registry) error {

	if m.Outbound != nil {
		if err := m.Outbound.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "outbound")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) contextValidateServicePlan(ctx context.Context, formats strfmt.Registry) error {

	if m.ServicePlan != nil {
		if err := m.ServicePlan.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "service_plan")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) contextValidateTransactions(ctx context.Context, formats strfmt.Registry) error {

	if m.Transactions != nil {
		if err := m.Transactions.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "transactions")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) contextValidateTwoway(ctx context.Context, formats strfmt.Registry) error {

	if m.Twoway != nil {
		if err := m.Twoway.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "twoway")
			}
			return err
		}
	}

	return nil
}

func (m *GetAccountResponseDataUIRestrictionsMyaccount) contextValidateUser(ctx context.Context, formats strfmt.Registry) error {

	if m.User != nil {
		if err := m.User.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("data" + "." + "ui_restrictions" + "." + "myaccount" + "." + "user")
			}
			return err
		}
	}

	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccount) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccount) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataUIRestrictionsMyaccount
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataUIRestrictionsMyaccountAccount get account response data UI restrictions myaccount account
//
// swagger:model GetAccountResponseDataUIRestrictionsMyaccountAccount
type GetAccountResponseDataUIRestrictionsMyaccountAccount struct {

	// show tab
	// Example: true
	ShowTab bool `json:"show_tab,omitempty"`
}

// Validate validates this get account response data UI restrictions myaccount account
func (m *GetAccountResponseDataUIRestrictionsMyaccountAccount) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data UI restrictions myaccount account based on context it is used
func (m *GetAccountResponseDataUIRestrictionsMyaccountAccount) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountAccount) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountAccount) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataUIRestrictionsMyaccountAccount
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataUIRestrictionsMyaccountBalance get account response data UI restrictions myaccount balance
//
// swagger:model GetAccountResponseDataUIRestrictionsMyaccountBalance
type GetAccountResponseDataUIRestrictionsMyaccountBalance struct {

	// show credit
	// Example: true
	ShowCredit bool `json:"show_credit,omitempty"`

	// show header
	// Example: true
	ShowHeader bool `json:"show_header,omitempty"`

	// show minutes
	// Example: true
	ShowMinutes bool `json:"show_minutes,omitempty"`

	// show tab
	// Example: true
	ShowTab bool `json:"show_tab,omitempty"`
}

// Validate validates this get account response data UI restrictions myaccount balance
func (m *GetAccountResponseDataUIRestrictionsMyaccountBalance) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data UI restrictions myaccount balance based on context it is used
func (m *GetAccountResponseDataUIRestrictionsMyaccountBalance) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountBalance) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountBalance) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataUIRestrictionsMyaccountBalance
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataUIRestrictionsMyaccountBilling get account response data UI restrictions myaccount billing
//
// swagger:model GetAccountResponseDataUIRestrictionsMyaccountBilling
type GetAccountResponseDataUIRestrictionsMyaccountBilling struct {

	// show tab
	// Example: true
	ShowTab bool `json:"show_tab,omitempty"`
}

// Validate validates this get account response data UI restrictions myaccount billing
func (m *GetAccountResponseDataUIRestrictionsMyaccountBilling) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data UI restrictions myaccount billing based on context it is used
func (m *GetAccountResponseDataUIRestrictionsMyaccountBilling) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountBilling) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountBilling) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataUIRestrictionsMyaccountBilling
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataUIRestrictionsMyaccountErrorTracker get account response data UI restrictions myaccount error tracker
//
// swagger:model GetAccountResponseDataUIRestrictionsMyaccountErrorTracker
type GetAccountResponseDataUIRestrictionsMyaccountErrorTracker struct {

	// show tab
	// Example: true
	ShowTab bool `json:"show_tab,omitempty"`
}

// Validate validates this get account response data UI restrictions myaccount error tracker
func (m *GetAccountResponseDataUIRestrictionsMyaccountErrorTracker) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data UI restrictions myaccount error tracker based on context it is used
func (m *GetAccountResponseDataUIRestrictionsMyaccountErrorTracker) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountErrorTracker) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountErrorTracker) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataUIRestrictionsMyaccountErrorTracker
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataUIRestrictionsMyaccountInbound get account response data UI restrictions myaccount inbound
//
// swagger:model GetAccountResponseDataUIRestrictionsMyaccountInbound
type GetAccountResponseDataUIRestrictionsMyaccountInbound struct {

	// show tab
	// Example: true
	ShowTab bool `json:"show_tab,omitempty"`
}

// Validate validates this get account response data UI restrictions myaccount inbound
func (m *GetAccountResponseDataUIRestrictionsMyaccountInbound) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data UI restrictions myaccount inbound based on context it is used
func (m *GetAccountResponseDataUIRestrictionsMyaccountInbound) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountInbound) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountInbound) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataUIRestrictionsMyaccountInbound
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataUIRestrictionsMyaccountOutbound get account response data UI restrictions myaccount outbound
//
// swagger:model GetAccountResponseDataUIRestrictionsMyaccountOutbound
type GetAccountResponseDataUIRestrictionsMyaccountOutbound struct {

	// show tab
	// Example: true
	ShowTab bool `json:"show_tab,omitempty"`
}

// Validate validates this get account response data UI restrictions myaccount outbound
func (m *GetAccountResponseDataUIRestrictionsMyaccountOutbound) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data UI restrictions myaccount outbound based on context it is used
func (m *GetAccountResponseDataUIRestrictionsMyaccountOutbound) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountOutbound) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountOutbound) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataUIRestrictionsMyaccountOutbound
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataUIRestrictionsMyaccountServicePlan get account response data UI restrictions myaccount service plan
//
// swagger:model GetAccountResponseDataUIRestrictionsMyaccountServicePlan
type GetAccountResponseDataUIRestrictionsMyaccountServicePlan struct {

	// show tab
	// Example: true
	ShowTab bool `json:"show_tab,omitempty"`
}

// Validate validates this get account response data UI restrictions myaccount service plan
func (m *GetAccountResponseDataUIRestrictionsMyaccountServicePlan) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data UI restrictions myaccount service plan based on context it is used
func (m *GetAccountResponseDataUIRestrictionsMyaccountServicePlan) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountServicePlan) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountServicePlan) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataUIRestrictionsMyaccountServicePlan
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataUIRestrictionsMyaccountTransactions get account response data UI restrictions myaccount transactions
//
// swagger:model GetAccountResponseDataUIRestrictionsMyaccountTransactions
type GetAccountResponseDataUIRestrictionsMyaccountTransactions struct {

	// show tab
	// Example: true
	ShowTab bool `json:"show_tab,omitempty"`
}

// Validate validates this get account response data UI restrictions myaccount transactions
func (m *GetAccountResponseDataUIRestrictionsMyaccountTransactions) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data UI restrictions myaccount transactions based on context it is used
func (m *GetAccountResponseDataUIRestrictionsMyaccountTransactions) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountTransactions) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountTransactions) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataUIRestrictionsMyaccountTransactions
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataUIRestrictionsMyaccountTwoway get account response data UI restrictions myaccount twoway
//
// swagger:model GetAccountResponseDataUIRestrictionsMyaccountTwoway
type GetAccountResponseDataUIRestrictionsMyaccountTwoway struct {

	// show tab
	// Example: true
	ShowTab bool `json:"show_tab,omitempty"`
}

// Validate validates this get account response data UI restrictions myaccount twoway
func (m *GetAccountResponseDataUIRestrictionsMyaccountTwoway) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data UI restrictions myaccount twoway based on context it is used
func (m *GetAccountResponseDataUIRestrictionsMyaccountTwoway) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountTwoway) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountTwoway) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataUIRestrictionsMyaccountTwoway
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}

// GetAccountResponseDataUIRestrictionsMyaccountUser get account response data UI restrictions myaccount user
//
// swagger:model GetAccountResponseDataUIRestrictionsMyaccountUser
type GetAccountResponseDataUIRestrictionsMyaccountUser struct {

	// show tab
	// Example: true
	ShowTab bool `json:"show_tab,omitempty"`
}

// Validate validates this get account response data UI restrictions myaccount user
func (m *GetAccountResponseDataUIRestrictionsMyaccountUser) Validate(formats strfmt.Registry) error {
	return nil
}

// ContextValidate validates this get account response data UI restrictions myaccount user based on context it is used
func (m *GetAccountResponseDataUIRestrictionsMyaccountUser) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	return nil
}

// MarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountUser) MarshalBinary() ([]byte, error) {
	if m == nil {
		return nil, nil
	}
	return swag.WriteJSON(m)
}

// UnmarshalBinary interface implementation
func (m *GetAccountResponseDataUIRestrictionsMyaccountUser) UnmarshalBinary(b []byte) error {
	var res GetAccountResponseDataUIRestrictionsMyaccountUser
	if err := swag.ReadJSON(b, &res); err != nil {
		return err
	}
	*m = res
	return nil
}