result.go

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

package 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"
)

// Result result
//
// swagger:model Result
type Result struct {

	// accept invitation result
	AcceptInvitationResult *AcceptInvitationResult `json:"acceptInvitationResult,omitempty"`

	// activate billing tier result
	ActivateBillingTierResult *ActivateBillingTierResult `json:"activateBillingTierResult,omitempty"`

	// create Api keys result
	CreateAPIKeysResult *CreateAPIKeysResult `json:"createApiKeysResult,omitempty"`

	// create Api only users result
	CreateAPIOnlyUsersResult *CreateAPIOnlyUsersResult `json:"createApiOnlyUsersResult,omitempty"`

	// create authenticators result
	CreateAuthenticatorsResult *CreateAuthenticatorsResult `json:"createAuthenticatorsResult,omitempty"`

	// create invitations result
	CreateInvitationsResult *CreateInvitationsResult `json:"createInvitationsResult,omitempty"`

	// create organization result
	CreateOrganizationResult *CreateOrganizationResult `json:"createOrganizationResult,omitempty"`

	// create policies result
	CreatePoliciesResult *CreatePoliciesResult `json:"createPoliciesResult,omitempty"`

	// create policy result
	CreatePolicyResult *CreatePolicyResult `json:"createPolicyResult,omitempty"`

	// create private key tag result
	CreatePrivateKeyTagResult *CreatePrivateKeyTagResult `json:"createPrivateKeyTagResult,omitempty"`

	// create private keys result
	CreatePrivateKeysResult *CreatePrivateKeysResult `json:"createPrivateKeysResult,omitempty"`

	// create private keys result v2
	CreatePrivateKeysResultV2 *CreatePrivateKeysResultV2 `json:"createPrivateKeysResultV2,omitempty"`

	// create sub organization result
	CreateSubOrganizationResult *CreateSubOrganizationResult `json:"createSubOrganizationResult,omitempty"`

	// create sub organization result v3
	CreateSubOrganizationResultV3 *CreateSubOrganizationResultV3 `json:"createSubOrganizationResultV3,omitempty"`

	// create sub organization result v4
	CreateSubOrganizationResultV4 *CreateSubOrganizationResultV4 `json:"createSubOrganizationResultV4,omitempty"`

	// create user tag result
	CreateUserTagResult *CreateUserTagResult `json:"createUserTagResult,omitempty"`

	// create users result
	CreateUsersResult *CreateUsersResult `json:"createUsersResult,omitempty"`

	// create wallet accounts result
	CreateWalletAccountsResult *CreateWalletAccountsResult `json:"createWalletAccountsResult,omitempty"`

	// create wallet result
	CreateWalletResult *CreateWalletResult `json:"createWalletResult,omitempty"`

	// delete Api keys result
	DeleteAPIKeysResult *DeleteAPIKeysResult `json:"deleteApiKeysResult,omitempty"`

	// delete authenticators result
	DeleteAuthenticatorsResult *DeleteAuthenticatorsResult `json:"deleteAuthenticatorsResult,omitempty"`

	// delete invitation result
	DeleteInvitationResult *DeleteInvitationResult `json:"deleteInvitationResult,omitempty"`

	// delete organization result
	DeleteOrganizationResult *DeleteOrganizationResult `json:"deleteOrganizationResult,omitempty"`

	// delete payment method result
	DeletePaymentMethodResult *DeletePaymentMethodResult `json:"deletePaymentMethodResult,omitempty"`

	// delete policy result
	DeletePolicyResult *DeletePolicyResult `json:"deletePolicyResult,omitempty"`

	// delete private key tags result
	DeletePrivateKeyTagsResult *DeletePrivateKeyTagsResult `json:"deletePrivateKeyTagsResult,omitempty"`

	// delete user tags result
	DeleteUserTagsResult *DeleteUserTagsResult `json:"deleteUserTagsResult,omitempty"`

	// delete users result
	DeleteUsersResult *DeleteUsersResult `json:"deleteUsersResult,omitempty"`

	// disable private key result
	DisablePrivateKeyResult *DisablePrivateKeyResult `json:"disablePrivateKeyResult,omitempty"`

	// email auth result
	EmailAuthResult *EmailAuthResult `json:"emailAuthResult,omitempty"`

	// export private key result
	ExportPrivateKeyResult *ExportPrivateKeyResult `json:"exportPrivateKeyResult,omitempty"`

	// export wallet account result
	ExportWalletAccountResult *ExportWalletAccountResult `json:"exportWalletAccountResult,omitempty"`

	// export wallet result
	ExportWalletResult *ExportWalletResult `json:"exportWalletResult,omitempty"`

	// import private key result
	ImportPrivateKeyResult *ImportPrivateKeyResult `json:"importPrivateKeyResult,omitempty"`

	// import wallet result
	ImportWalletResult *ImportWalletResult `json:"importWalletResult,omitempty"`

	// init import private key result
	InitImportPrivateKeyResult *InitImportPrivateKeyResult `json:"initImportPrivateKeyResult,omitempty"`

	// init import wallet result
	InitImportWalletResult *InitImportWalletResult `json:"initImportWalletResult,omitempty"`

	// init user email recovery result
	InitUserEmailRecoveryResult *InitUserEmailRecoveryResult `json:"initUserEmailRecoveryResult,omitempty"`

	// recover user result
	RecoverUserResult *RecoverUserResult `json:"recoverUserResult,omitempty"`

	// remove organization feature result
	RemoveOrganizationFeatureResult *RemoveOrganizationFeatureResult `json:"removeOrganizationFeatureResult,omitempty"`

	// set organization feature result
	SetOrganizationFeatureResult *SetOrganizationFeatureResult `json:"setOrganizationFeatureResult,omitempty"`

	// set payment method result
	SetPaymentMethodResult *SetPaymentMethodResult `json:"setPaymentMethodResult,omitempty"`

	// sign raw payload result
	SignRawPayloadResult *SignRawPayloadResult `json:"signRawPayloadResult,omitempty"`

	// sign raw payloads result
	SignRawPayloadsResult *SignRawPayloadsResult `json:"signRawPayloadsResult,omitempty"`

	// sign transaction result
	SignTransactionResult *SignTransactionResult `json:"signTransactionResult,omitempty"`

	// update allowed origins result
	UpdateAllowedOriginsResult UpdateAllowedOriginsResult `json:"updateAllowedOriginsResult,omitempty"`

	// update policy result
	UpdatePolicyResult *UpdatePolicyResult `json:"updatePolicyResult,omitempty"`

	// update private key tag result
	UpdatePrivateKeyTagResult *UpdatePrivateKeyTagResult `json:"updatePrivateKeyTagResult,omitempty"`

	// update root quorum result
	UpdateRootQuorumResult UpdateRootQuorumResult `json:"updateRootQuorumResult,omitempty"`

	// update user result
	UpdateUserResult *UpdateUserResult `json:"updateUserResult,omitempty"`

	// update user tag result
	UpdateUserTagResult *UpdateUserTagResult `json:"updateUserTagResult,omitempty"`
}

// Validate validates this result
func (m *Result) Validate(formats strfmt.Registry) error {
	var res []error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *Result) validateAcceptInvitationResult(formats strfmt.Registry) error {
	if swag.IsZero(m.AcceptInvitationResult) { // not required
		return nil
	}

	if m.AcceptInvitationResult != nil {
		if err := m.AcceptInvitationResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("acceptInvitationResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("acceptInvitationResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateActivateBillingTierResult(formats strfmt.Registry) error {
	if swag.IsZero(m.ActivateBillingTierResult) { // not required
		return nil
	}

	if m.ActivateBillingTierResult != nil {
		if err := m.ActivateBillingTierResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("activateBillingTierResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("activateBillingTierResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreateAPIKeysResult(formats strfmt.Registry) error {
	if swag.IsZero(m.CreateAPIKeysResult) { // not required
		return nil
	}

	if m.CreateAPIKeysResult != nil {
		if err := m.CreateAPIKeysResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createApiKeysResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createApiKeysResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreateAPIOnlyUsersResult(formats strfmt.Registry) error {
	if swag.IsZero(m.CreateAPIOnlyUsersResult) { // not required
		return nil
	}

	if m.CreateAPIOnlyUsersResult != nil {
		if err := m.CreateAPIOnlyUsersResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createApiOnlyUsersResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createApiOnlyUsersResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreateAuthenticatorsResult(formats strfmt.Registry) error {
	if swag.IsZero(m.CreateAuthenticatorsResult) { // not required
		return nil
	}

	if m.CreateAuthenticatorsResult != nil {
		if err := m.CreateAuthenticatorsResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createAuthenticatorsResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createAuthenticatorsResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreateInvitationsResult(formats strfmt.Registry) error {
	if swag.IsZero(m.CreateInvitationsResult) { // not required
		return nil
	}

	if m.CreateInvitationsResult != nil {
		if err := m.CreateInvitationsResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createInvitationsResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createInvitationsResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreateOrganizationResult(formats strfmt.Registry) error {
	if swag.IsZero(m.CreateOrganizationResult) { // not required
		return nil
	}

	if m.CreateOrganizationResult != nil {
		if err := m.CreateOrganizationResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createOrganizationResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createOrganizationResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreatePoliciesResult(formats strfmt.Registry) error {
	if swag.IsZero(m.CreatePoliciesResult) { // not required
		return nil
	}

	if m.CreatePoliciesResult != nil {
		if err := m.CreatePoliciesResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createPoliciesResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createPoliciesResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreatePolicyResult(formats strfmt.Registry) error {
	if swag.IsZero(m.CreatePolicyResult) { // not required
		return nil
	}

	if m.CreatePolicyResult != nil {
		if err := m.CreatePolicyResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createPolicyResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createPolicyResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreatePrivateKeyTagResult(formats strfmt.Registry) error {
	if swag.IsZero(m.CreatePrivateKeyTagResult) { // not required
		return nil
	}

	if m.CreatePrivateKeyTagResult != nil {
		if err := m.CreatePrivateKeyTagResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createPrivateKeyTagResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createPrivateKeyTagResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreatePrivateKeysResult(formats strfmt.Registry) error {
	if swag.IsZero(m.CreatePrivateKeysResult) { // not required
		return nil
	}

	if m.CreatePrivateKeysResult != nil {
		if err := m.CreatePrivateKeysResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createPrivateKeysResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createPrivateKeysResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreatePrivateKeysResultV2(formats strfmt.Registry) error {
	if swag.IsZero(m.CreatePrivateKeysResultV2) { // not required
		return nil
	}

	if m.CreatePrivateKeysResultV2 != nil {
		if err := m.CreatePrivateKeysResultV2.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createPrivateKeysResultV2")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createPrivateKeysResultV2")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreateSubOrganizationResult(formats strfmt.Registry) error {
	if swag.IsZero(m.CreateSubOrganizationResult) { // not required
		return nil
	}

	if m.CreateSubOrganizationResult != nil {
		if err := m.CreateSubOrganizationResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createSubOrganizationResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createSubOrganizationResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreateSubOrganizationResultV3(formats strfmt.Registry) error {
	if swag.IsZero(m.CreateSubOrganizationResultV3) { // not required
		return nil
	}

	if m.CreateSubOrganizationResultV3 != nil {
		if err := m.CreateSubOrganizationResultV3.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createSubOrganizationResultV3")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createSubOrganizationResultV3")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreateSubOrganizationResultV4(formats strfmt.Registry) error {
	if swag.IsZero(m.CreateSubOrganizationResultV4) { // not required
		return nil
	}

	if m.CreateSubOrganizationResultV4 != nil {
		if err := m.CreateSubOrganizationResultV4.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createSubOrganizationResultV4")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createSubOrganizationResultV4")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreateUserTagResult(formats strfmt.Registry) error {
	if swag.IsZero(m.CreateUserTagResult) { // not required
		return nil
	}

	if m.CreateUserTagResult != nil {
		if err := m.CreateUserTagResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createUserTagResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createUserTagResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreateUsersResult(formats strfmt.Registry) error {
	if swag.IsZero(m.CreateUsersResult) { // not required
		return nil
	}

	if m.CreateUsersResult != nil {
		if err := m.CreateUsersResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createUsersResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createUsersResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreateWalletAccountsResult(formats strfmt.Registry) error {
	if swag.IsZero(m.CreateWalletAccountsResult) { // not required
		return nil
	}

	if m.CreateWalletAccountsResult != nil {
		if err := m.CreateWalletAccountsResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createWalletAccountsResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createWalletAccountsResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateCreateWalletResult(formats strfmt.Registry) error {
	if swag.IsZero(m.CreateWalletResult) { // not required
		return nil
	}

	if m.CreateWalletResult != nil {
		if err := m.CreateWalletResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createWalletResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createWalletResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateDeleteAPIKeysResult(formats strfmt.Registry) error {
	if swag.IsZero(m.DeleteAPIKeysResult) { // not required
		return nil
	}

	if m.DeleteAPIKeysResult != nil {
		if err := m.DeleteAPIKeysResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deleteApiKeysResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deleteApiKeysResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateDeleteAuthenticatorsResult(formats strfmt.Registry) error {
	if swag.IsZero(m.DeleteAuthenticatorsResult) { // not required
		return nil
	}

	if m.DeleteAuthenticatorsResult != nil {
		if err := m.DeleteAuthenticatorsResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deleteAuthenticatorsResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deleteAuthenticatorsResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateDeleteInvitationResult(formats strfmt.Registry) error {
	if swag.IsZero(m.DeleteInvitationResult) { // not required
		return nil
	}

	if m.DeleteInvitationResult != nil {
		if err := m.DeleteInvitationResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deleteInvitationResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deleteInvitationResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateDeleteOrganizationResult(formats strfmt.Registry) error {
	if swag.IsZero(m.DeleteOrganizationResult) { // not required
		return nil
	}

	if m.DeleteOrganizationResult != nil {
		if err := m.DeleteOrganizationResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deleteOrganizationResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deleteOrganizationResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateDeletePaymentMethodResult(formats strfmt.Registry) error {
	if swag.IsZero(m.DeletePaymentMethodResult) { // not required
		return nil
	}

	if m.DeletePaymentMethodResult != nil {
		if err := m.DeletePaymentMethodResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deletePaymentMethodResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deletePaymentMethodResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateDeletePolicyResult(formats strfmt.Registry) error {
	if swag.IsZero(m.DeletePolicyResult) { // not required
		return nil
	}

	if m.DeletePolicyResult != nil {
		if err := m.DeletePolicyResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deletePolicyResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deletePolicyResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateDeletePrivateKeyTagsResult(formats strfmt.Registry) error {
	if swag.IsZero(m.DeletePrivateKeyTagsResult) { // not required
		return nil
	}

	if m.DeletePrivateKeyTagsResult != nil {
		if err := m.DeletePrivateKeyTagsResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deletePrivateKeyTagsResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deletePrivateKeyTagsResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateDeleteUserTagsResult(formats strfmt.Registry) error {
	if swag.IsZero(m.DeleteUserTagsResult) { // not required
		return nil
	}

	if m.DeleteUserTagsResult != nil {
		if err := m.DeleteUserTagsResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deleteUserTagsResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deleteUserTagsResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateDeleteUsersResult(formats strfmt.Registry) error {
	if swag.IsZero(m.DeleteUsersResult) { // not required
		return nil
	}

	if m.DeleteUsersResult != nil {
		if err := m.DeleteUsersResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deleteUsersResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deleteUsersResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateDisablePrivateKeyResult(formats strfmt.Registry) error {
	if swag.IsZero(m.DisablePrivateKeyResult) { // not required
		return nil
	}

	if m.DisablePrivateKeyResult != nil {
		if err := m.DisablePrivateKeyResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("disablePrivateKeyResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("disablePrivateKeyResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateEmailAuthResult(formats strfmt.Registry) error {
	if swag.IsZero(m.EmailAuthResult) { // not required
		return nil
	}

	if m.EmailAuthResult != nil {
		if err := m.EmailAuthResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("emailAuthResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("emailAuthResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateExportPrivateKeyResult(formats strfmt.Registry) error {
	if swag.IsZero(m.ExportPrivateKeyResult) { // not required
		return nil
	}

	if m.ExportPrivateKeyResult != nil {
		if err := m.ExportPrivateKeyResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("exportPrivateKeyResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("exportPrivateKeyResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateExportWalletAccountResult(formats strfmt.Registry) error {
	if swag.IsZero(m.ExportWalletAccountResult) { // not required
		return nil
	}

	if m.ExportWalletAccountResult != nil {
		if err := m.ExportWalletAccountResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("exportWalletAccountResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("exportWalletAccountResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateExportWalletResult(formats strfmt.Registry) error {
	if swag.IsZero(m.ExportWalletResult) { // not required
		return nil
	}

	if m.ExportWalletResult != nil {
		if err := m.ExportWalletResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("exportWalletResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("exportWalletResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateImportPrivateKeyResult(formats strfmt.Registry) error {
	if swag.IsZero(m.ImportPrivateKeyResult) { // not required
		return nil
	}

	if m.ImportPrivateKeyResult != nil {
		if err := m.ImportPrivateKeyResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("importPrivateKeyResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("importPrivateKeyResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateImportWalletResult(formats strfmt.Registry) error {
	if swag.IsZero(m.ImportWalletResult) { // not required
		return nil
	}

	if m.ImportWalletResult != nil {
		if err := m.ImportWalletResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("importWalletResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("importWalletResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateInitImportPrivateKeyResult(formats strfmt.Registry) error {
	if swag.IsZero(m.InitImportPrivateKeyResult) { // not required
		return nil
	}

	if m.InitImportPrivateKeyResult != nil {
		if err := m.InitImportPrivateKeyResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("initImportPrivateKeyResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("initImportPrivateKeyResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateInitImportWalletResult(formats strfmt.Registry) error {
	if swag.IsZero(m.InitImportWalletResult) { // not required
		return nil
	}

	if m.InitImportWalletResult != nil {
		if err := m.InitImportWalletResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("initImportWalletResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("initImportWalletResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateInitUserEmailRecoveryResult(formats strfmt.Registry) error {
	if swag.IsZero(m.InitUserEmailRecoveryResult) { // not required
		return nil
	}

	if m.InitUserEmailRecoveryResult != nil {
		if err := m.InitUserEmailRecoveryResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("initUserEmailRecoveryResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("initUserEmailRecoveryResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateRecoverUserResult(formats strfmt.Registry) error {
	if swag.IsZero(m.RecoverUserResult) { // not required
		return nil
	}

	if m.RecoverUserResult != nil {
		if err := m.RecoverUserResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("recoverUserResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("recoverUserResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateRemoveOrganizationFeatureResult(formats strfmt.Registry) error {
	if swag.IsZero(m.RemoveOrganizationFeatureResult) { // not required
		return nil
	}

	if m.RemoveOrganizationFeatureResult != nil {
		if err := m.RemoveOrganizationFeatureResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("removeOrganizationFeatureResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("removeOrganizationFeatureResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateSetOrganizationFeatureResult(formats strfmt.Registry) error {
	if swag.IsZero(m.SetOrganizationFeatureResult) { // not required
		return nil
	}

	if m.SetOrganizationFeatureResult != nil {
		if err := m.SetOrganizationFeatureResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("setOrganizationFeatureResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("setOrganizationFeatureResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateSetPaymentMethodResult(formats strfmt.Registry) error {
	if swag.IsZero(m.SetPaymentMethodResult) { // not required
		return nil
	}

	if m.SetPaymentMethodResult != nil {
		if err := m.SetPaymentMethodResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("setPaymentMethodResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("setPaymentMethodResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateSignRawPayloadResult(formats strfmt.Registry) error {
	if swag.IsZero(m.SignRawPayloadResult) { // not required
		return nil
	}

	if m.SignRawPayloadResult != nil {
		if err := m.SignRawPayloadResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("signRawPayloadResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("signRawPayloadResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateSignRawPayloadsResult(formats strfmt.Registry) error {
	if swag.IsZero(m.SignRawPayloadsResult) { // not required
		return nil
	}

	if m.SignRawPayloadsResult != nil {
		if err := m.SignRawPayloadsResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("signRawPayloadsResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("signRawPayloadsResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateSignTransactionResult(formats strfmt.Registry) error {
	if swag.IsZero(m.SignTransactionResult) { // not required
		return nil
	}

	if m.SignTransactionResult != nil {
		if err := m.SignTransactionResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("signTransactionResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("signTransactionResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateUpdatePolicyResult(formats strfmt.Registry) error {
	if swag.IsZero(m.UpdatePolicyResult) { // not required
		return nil
	}

	if m.UpdatePolicyResult != nil {
		if err := m.UpdatePolicyResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("updatePolicyResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("updatePolicyResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateUpdatePrivateKeyTagResult(formats strfmt.Registry) error {
	if swag.IsZero(m.UpdatePrivateKeyTagResult) { // not required
		return nil
	}

	if m.UpdatePrivateKeyTagResult != nil {
		if err := m.UpdatePrivateKeyTagResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("updatePrivateKeyTagResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("updatePrivateKeyTagResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateUpdateUserResult(formats strfmt.Registry) error {
	if swag.IsZero(m.UpdateUserResult) { // not required
		return nil
	}

	if m.UpdateUserResult != nil {
		if err := m.UpdateUserResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("updateUserResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("updateUserResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) validateUpdateUserTagResult(formats strfmt.Registry) error {
	if swag.IsZero(m.UpdateUserTagResult) { // not required
		return nil
	}

	if m.UpdateUserTagResult != nil {
		if err := m.UpdateUserTagResult.Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("updateUserTagResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("updateUserTagResult")
			}
			return err
		}
	}

	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *Result) contextValidateAcceptInvitationResult(ctx context.Context, formats strfmt.Registry) error {

	if m.AcceptInvitationResult != nil {

		if swag.IsZero(m.AcceptInvitationResult) { // not required
			return nil
		}

		if err := m.AcceptInvitationResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("acceptInvitationResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("acceptInvitationResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateActivateBillingTierResult(ctx context.Context, formats strfmt.Registry) error {

	if m.ActivateBillingTierResult != nil {

		if swag.IsZero(m.ActivateBillingTierResult) { // not required
			return nil
		}

		if err := m.ActivateBillingTierResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("activateBillingTierResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("activateBillingTierResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreateAPIKeysResult(ctx context.Context, formats strfmt.Registry) error {

	if m.CreateAPIKeysResult != nil {

		if swag.IsZero(m.CreateAPIKeysResult) { // not required
			return nil
		}

		if err := m.CreateAPIKeysResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createApiKeysResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createApiKeysResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreateAPIOnlyUsersResult(ctx context.Context, formats strfmt.Registry) error {

	if m.CreateAPIOnlyUsersResult != nil {

		if swag.IsZero(m.CreateAPIOnlyUsersResult) { // not required
			return nil
		}

		if err := m.CreateAPIOnlyUsersResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createApiOnlyUsersResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createApiOnlyUsersResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreateAuthenticatorsResult(ctx context.Context, formats strfmt.Registry) error {

	if m.CreateAuthenticatorsResult != nil {

		if swag.IsZero(m.CreateAuthenticatorsResult) { // not required
			return nil
		}

		if err := m.CreateAuthenticatorsResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createAuthenticatorsResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createAuthenticatorsResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreateInvitationsResult(ctx context.Context, formats strfmt.Registry) error {

	if m.CreateInvitationsResult != nil {

		if swag.IsZero(m.CreateInvitationsResult) { // not required
			return nil
		}

		if err := m.CreateInvitationsResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createInvitationsResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createInvitationsResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreateOrganizationResult(ctx context.Context, formats strfmt.Registry) error {

	if m.CreateOrganizationResult != nil {

		if swag.IsZero(m.CreateOrganizationResult) { // not required
			return nil
		}

		if err := m.CreateOrganizationResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createOrganizationResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createOrganizationResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreatePoliciesResult(ctx context.Context, formats strfmt.Registry) error {

	if m.CreatePoliciesResult != nil {

		if swag.IsZero(m.CreatePoliciesResult) { // not required
			return nil
		}

		if err := m.CreatePoliciesResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createPoliciesResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createPoliciesResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreatePolicyResult(ctx context.Context, formats strfmt.Registry) error {

	if m.CreatePolicyResult != nil {

		if swag.IsZero(m.CreatePolicyResult) { // not required
			return nil
		}

		if err := m.CreatePolicyResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createPolicyResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createPolicyResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreatePrivateKeyTagResult(ctx context.Context, formats strfmt.Registry) error {

	if m.CreatePrivateKeyTagResult != nil {

		if swag.IsZero(m.CreatePrivateKeyTagResult) { // not required
			return nil
		}

		if err := m.CreatePrivateKeyTagResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createPrivateKeyTagResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createPrivateKeyTagResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreatePrivateKeysResult(ctx context.Context, formats strfmt.Registry) error {

	if m.CreatePrivateKeysResult != nil {

		if swag.IsZero(m.CreatePrivateKeysResult) { // not required
			return nil
		}

		if err := m.CreatePrivateKeysResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createPrivateKeysResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createPrivateKeysResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreatePrivateKeysResultV2(ctx context.Context, formats strfmt.Registry) error {

	if m.CreatePrivateKeysResultV2 != nil {

		if swag.IsZero(m.CreatePrivateKeysResultV2) { // not required
			return nil
		}

		if err := m.CreatePrivateKeysResultV2.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createPrivateKeysResultV2")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createPrivateKeysResultV2")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreateSubOrganizationResult(ctx context.Context, formats strfmt.Registry) error {

	if m.CreateSubOrganizationResult != nil {

		if swag.IsZero(m.CreateSubOrganizationResult) { // not required
			return nil
		}

		if err := m.CreateSubOrganizationResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createSubOrganizationResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createSubOrganizationResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreateSubOrganizationResultV3(ctx context.Context, formats strfmt.Registry) error {

	if m.CreateSubOrganizationResultV3 != nil {

		if swag.IsZero(m.CreateSubOrganizationResultV3) { // not required
			return nil
		}

		if err := m.CreateSubOrganizationResultV3.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createSubOrganizationResultV3")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createSubOrganizationResultV3")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreateSubOrganizationResultV4(ctx context.Context, formats strfmt.Registry) error {

	if m.CreateSubOrganizationResultV4 != nil {

		if swag.IsZero(m.CreateSubOrganizationResultV4) { // not required
			return nil
		}

		if err := m.CreateSubOrganizationResultV4.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createSubOrganizationResultV4")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createSubOrganizationResultV4")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreateUserTagResult(ctx context.Context, formats strfmt.Registry) error {

	if m.CreateUserTagResult != nil {

		if swag.IsZero(m.CreateUserTagResult) { // not required
			return nil
		}

		if err := m.CreateUserTagResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createUserTagResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createUserTagResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreateUsersResult(ctx context.Context, formats strfmt.Registry) error {

	if m.CreateUsersResult != nil {

		if swag.IsZero(m.CreateUsersResult) { // not required
			return nil
		}

		if err := m.CreateUsersResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createUsersResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createUsersResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreateWalletAccountsResult(ctx context.Context, formats strfmt.Registry) error {

	if m.CreateWalletAccountsResult != nil {

		if swag.IsZero(m.CreateWalletAccountsResult) { // not required
			return nil
		}

		if err := m.CreateWalletAccountsResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createWalletAccountsResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createWalletAccountsResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateCreateWalletResult(ctx context.Context, formats strfmt.Registry) error {

	if m.CreateWalletResult != nil {

		if swag.IsZero(m.CreateWalletResult) { // not required
			return nil
		}

		if err := m.CreateWalletResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("createWalletResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("createWalletResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateDeleteAPIKeysResult(ctx context.Context, formats strfmt.Registry) error {

	if m.DeleteAPIKeysResult != nil {

		if swag.IsZero(m.DeleteAPIKeysResult) { // not required
			return nil
		}

		if err := m.DeleteAPIKeysResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deleteApiKeysResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deleteApiKeysResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateDeleteAuthenticatorsResult(ctx context.Context, formats strfmt.Registry) error {

	if m.DeleteAuthenticatorsResult != nil {

		if swag.IsZero(m.DeleteAuthenticatorsResult) { // not required
			return nil
		}

		if err := m.DeleteAuthenticatorsResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deleteAuthenticatorsResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deleteAuthenticatorsResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateDeleteInvitationResult(ctx context.Context, formats strfmt.Registry) error {

	if m.DeleteInvitationResult != nil {

		if swag.IsZero(m.DeleteInvitationResult) { // not required
			return nil
		}

		if err := m.DeleteInvitationResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deleteInvitationResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deleteInvitationResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateDeleteOrganizationResult(ctx context.Context, formats strfmt.Registry) error {

	if m.DeleteOrganizationResult != nil {

		if swag.IsZero(m.DeleteOrganizationResult) { // not required
			return nil
		}

		if err := m.DeleteOrganizationResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deleteOrganizationResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deleteOrganizationResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateDeletePaymentMethodResult(ctx context.Context, formats strfmt.Registry) error {

	if m.DeletePaymentMethodResult != nil {

		if swag.IsZero(m.DeletePaymentMethodResult) { // not required
			return nil
		}

		if err := m.DeletePaymentMethodResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deletePaymentMethodResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deletePaymentMethodResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateDeletePolicyResult(ctx context.Context, formats strfmt.Registry) error {

	if m.DeletePolicyResult != nil {

		if swag.IsZero(m.DeletePolicyResult) { // not required
			return nil
		}

		if err := m.DeletePolicyResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deletePolicyResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deletePolicyResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateDeletePrivateKeyTagsResult(ctx context.Context, formats strfmt.Registry) error {

	if m.DeletePrivateKeyTagsResult != nil {

		if swag.IsZero(m.DeletePrivateKeyTagsResult) { // not required
			return nil
		}

		if err := m.DeletePrivateKeyTagsResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deletePrivateKeyTagsResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deletePrivateKeyTagsResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateDeleteUserTagsResult(ctx context.Context, formats strfmt.Registry) error {

	if m.DeleteUserTagsResult != nil {

		if swag.IsZero(m.DeleteUserTagsResult) { // not required
			return nil
		}

		if err := m.DeleteUserTagsResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deleteUserTagsResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deleteUserTagsResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateDeleteUsersResult(ctx context.Context, formats strfmt.Registry) error {

	if m.DeleteUsersResult != nil {

		if swag.IsZero(m.DeleteUsersResult) { // not required
			return nil
		}

		if err := m.DeleteUsersResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("deleteUsersResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("deleteUsersResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateDisablePrivateKeyResult(ctx context.Context, formats strfmt.Registry) error {

	if m.DisablePrivateKeyResult != nil {

		if swag.IsZero(m.DisablePrivateKeyResult) { // not required
			return nil
		}

		if err := m.DisablePrivateKeyResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("disablePrivateKeyResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("disablePrivateKeyResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateEmailAuthResult(ctx context.Context, formats strfmt.Registry) error {

	if m.EmailAuthResult != nil {

		if swag.IsZero(m.EmailAuthResult) { // not required
			return nil
		}

		if err := m.EmailAuthResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("emailAuthResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("emailAuthResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateExportPrivateKeyResult(ctx context.Context, formats strfmt.Registry) error {

	if m.ExportPrivateKeyResult != nil {

		if swag.IsZero(m.ExportPrivateKeyResult) { // not required
			return nil
		}

		if err := m.ExportPrivateKeyResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("exportPrivateKeyResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("exportPrivateKeyResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateExportWalletAccountResult(ctx context.Context, formats strfmt.Registry) error {

	if m.ExportWalletAccountResult != nil {

		if swag.IsZero(m.ExportWalletAccountResult) { // not required
			return nil
		}

		if err := m.ExportWalletAccountResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("exportWalletAccountResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("exportWalletAccountResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateExportWalletResult(ctx context.Context, formats strfmt.Registry) error {

	if m.ExportWalletResult != nil {

		if swag.IsZero(m.ExportWalletResult) { // not required
			return nil
		}

		if err := m.ExportWalletResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("exportWalletResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("exportWalletResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateImportPrivateKeyResult(ctx context.Context, formats strfmt.Registry) error {

	if m.ImportPrivateKeyResult != nil {

		if swag.IsZero(m.ImportPrivateKeyResult) { // not required
			return nil
		}

		if err := m.ImportPrivateKeyResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("importPrivateKeyResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("importPrivateKeyResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateImportWalletResult(ctx context.Context, formats strfmt.Registry) error {

	if m.ImportWalletResult != nil {

		if swag.IsZero(m.ImportWalletResult) { // not required
			return nil
		}

		if err := m.ImportWalletResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("importWalletResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("importWalletResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateInitImportPrivateKeyResult(ctx context.Context, formats strfmt.Registry) error {

	if m.InitImportPrivateKeyResult != nil {

		if swag.IsZero(m.InitImportPrivateKeyResult) { // not required
			return nil
		}

		if err := m.InitImportPrivateKeyResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("initImportPrivateKeyResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("initImportPrivateKeyResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateInitImportWalletResult(ctx context.Context, formats strfmt.Registry) error {

	if m.InitImportWalletResult != nil {

		if swag.IsZero(m.InitImportWalletResult) { // not required
			return nil
		}

		if err := m.InitImportWalletResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("initImportWalletResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("initImportWalletResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateInitUserEmailRecoveryResult(ctx context.Context, formats strfmt.Registry) error {

	if m.InitUserEmailRecoveryResult != nil {

		if swag.IsZero(m.InitUserEmailRecoveryResult) { // not required
			return nil
		}

		if err := m.InitUserEmailRecoveryResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("initUserEmailRecoveryResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("initUserEmailRecoveryResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateRecoverUserResult(ctx context.Context, formats strfmt.Registry) error {

	if m.RecoverUserResult != nil {

		if swag.IsZero(m.RecoverUserResult) { // not required
			return nil
		}

		if err := m.RecoverUserResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("recoverUserResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("recoverUserResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateRemoveOrganizationFeatureResult(ctx context.Context, formats strfmt.Registry) error {

	if m.RemoveOrganizationFeatureResult != nil {

		if swag.IsZero(m.RemoveOrganizationFeatureResult) { // not required
			return nil
		}

		if err := m.RemoveOrganizationFeatureResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("removeOrganizationFeatureResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("removeOrganizationFeatureResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateSetOrganizationFeatureResult(ctx context.Context, formats strfmt.Registry) error {

	if m.SetOrganizationFeatureResult != nil {

		if swag.IsZero(m.SetOrganizationFeatureResult) { // not required
			return nil
		}

		if err := m.SetOrganizationFeatureResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("setOrganizationFeatureResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("setOrganizationFeatureResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateSetPaymentMethodResult(ctx context.Context, formats strfmt.Registry) error {

	if m.SetPaymentMethodResult != nil {

		if swag.IsZero(m.SetPaymentMethodResult) { // not required
			return nil
		}

		if err := m.SetPaymentMethodResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("setPaymentMethodResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("setPaymentMethodResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateSignRawPayloadResult(ctx context.Context, formats strfmt.Registry) error {

	if m.SignRawPayloadResult != nil {

		if swag.IsZero(m.SignRawPayloadResult) { // not required
			return nil
		}

		if err := m.SignRawPayloadResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("signRawPayloadResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("signRawPayloadResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateSignRawPayloadsResult(ctx context.Context, formats strfmt.Registry) error {

	if m.SignRawPayloadsResult != nil {

		if swag.IsZero(m.SignRawPayloadsResult) { // not required
			return nil
		}

		if err := m.SignRawPayloadsResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("signRawPayloadsResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("signRawPayloadsResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateSignTransactionResult(ctx context.Context, formats strfmt.Registry) error {

	if m.SignTransactionResult != nil {

		if swag.IsZero(m.SignTransactionResult) { // not required
			return nil
		}

		if err := m.SignTransactionResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("signTransactionResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("signTransactionResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateUpdatePolicyResult(ctx context.Context, formats strfmt.Registry) error {

	if m.UpdatePolicyResult != nil {

		if swag.IsZero(m.UpdatePolicyResult) { // not required
			return nil
		}

		if err := m.UpdatePolicyResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("updatePolicyResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("updatePolicyResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateUpdatePrivateKeyTagResult(ctx context.Context, formats strfmt.Registry) error {

	if m.UpdatePrivateKeyTagResult != nil {

		if swag.IsZero(m.UpdatePrivateKeyTagResult) { // not required
			return nil
		}

		if err := m.UpdatePrivateKeyTagResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("updatePrivateKeyTagResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("updatePrivateKeyTagResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateUpdateUserResult(ctx context.Context, formats strfmt.Registry) error {

	if m.UpdateUserResult != nil {

		if swag.IsZero(m.UpdateUserResult) { // not required
			return nil
		}

		if err := m.UpdateUserResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("updateUserResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("updateUserResult")
			}
			return err
		}
	}

	return nil
}

func (m *Result) contextValidateUpdateUserTagResult(ctx context.Context, formats strfmt.Registry) error {

	if m.UpdateUserTagResult != nil {

		if swag.IsZero(m.UpdateUserTagResult) { // not required
			return nil
		}

		if err := m.UpdateUserTagResult.ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("updateUserTagResult")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("updateUserTagResult")
			}
			return err
		}
	}

	return nil
}

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

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