Enum CoverageType 

#[repr(u8)]
pub enum CoverageType {
    Homeowners = 0,
    Renters = 1,
    Landlord = 2,
    CommercialProperty = 3,
    Flood = 4,
    Earthquake = 5,
    Fire = 6,
    Windstorm = 7,
    AutoLiability = 20,
    AutoCollision = 21,
    AutoComprehensive = 22,
    UninsuredMotorist = 23,
    PersonalInjuryProtection = 24,
    GapInsurance = 25,
    Watercraft = 26,
    Aircraft = 27,
    OwnersTitlePolicy = 40,
    LendersTitlePolicy = 41,
    ExtendedCoverage = 42,
    GeneralLiability = 50,
    ProfessionalLiability = 51,
    UmbrellaPolicy = 52,
    ProductLiability = 53,
    BuildersRisk = 60,
    InlandMarine = 61,
    ValuableArticles = 62,
    EquipmentBreakdown = 63,
    Other = 255,
}

Insurance coverage type

Variants

Homeowners = 0

Homeowners insurance

Renters = 1

Renters insurance

Landlord = 2

Landlord insurance

CommercialProperty = 3

Commercial property

Flood = 4

Flood insurance

Earthquake = 5

Earthquake insurance

Fire = 6

Fire insurance

Windstorm = 7

Windstorm/hurricane

AutoLiability = 20

Auto liability

AutoCollision = 21

Auto collision

AutoComprehensive = 22

Auto comprehensive

UninsuredMotorist = 23

Uninsured motorist

PersonalInjuryProtection = 24

Personal injury protection

GapInsurance = 25

Gap insurance

Watercraft = 26

Watercraft insurance

Aircraft = 27

Aircraft insurance

OwnersTitlePolicy = 40

Owner’s title policy

LendersTitlePolicy = 41

Lender’s title policy

ExtendedCoverage = 42

Extended coverage

GeneralLiability = 50

General liability

ProfessionalLiability = 51

Professional liability

UmbrellaPolicy = 52

Umbrella policy

ProductLiability = 53

Product liability

BuildersRisk = 60

Builder’s risk

InlandMarine = 61

Inland marine

ValuableArticles = 62

Valuable articles

EquipmentBreakdown = 63

Equipment breakdown

Other = 255

Other coverage

Trait Implementations

impl Clone for CoverageType

fn clone(&self) -> CoverageType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CoverageType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CoverageType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for CoverageType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CoverageType

fn eq(&self, other: &CoverageType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CoverageType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for CoverageType

impl Eq for CoverageType

impl StructuralPartialEq for CoverageType