NAME

       MIME::Type - description of one MIME type

SYNOPSIS

         use MIME::Types;
         my $mimetypes = MIME::Types->new;
         my MIME::Type $plaintext = $mimetypes->type('text/plain');
         print $plaintext->mediaType;   # text
         print $plaintext->subType;     # plain

         my @ext = $plaintext->extensions;
         print "@ext"                   # txt asc c cc h hh cpp

         print $plaintext->encoding     # 8bit
         if($plaintext->isBinary)       # false
         if($plaintext->isText)         # true
         if($plaintext->equals('text/plain') {...}
         if($plaintext eq 'text/plain') # same

         print MIME::Type->simplified('x-appl/x-zip') #  'appl/zip'

DESCRIPTION

       MIME types are used in MIME entities, for instance as part of e-mail and HTTP traffic.  Sometimes real
       knowledge about a mime-type is need.  Objects of "MIME::Type" store the information on one such type.

OVERLOADED

       overload: "" stringification
           The stringification (use of the object in a place where a string is required) will result in the type
           name, the same as type() returns.

           » example: use of stringification

             my $mime = MIME::Type->new('text/html');
             print "$mime\n";   # explicit stringification
             print $mime;       # implicit stringification

       overload: == numerical comparison
           Compare whether the type() of the objects is the same.

       overload: cmp string comparison
           When a MIME::Type object is compared to either a string or another MIME::Type, the equals() method is
           called.  Comparison is smart, which means that it extends common string comparison with some features
           which are defined in the related RFCs.

METHODS

   Initiation
       $class->new(%options)
           Create (instantiate) a new MIME::Type object which manages one mime type.

            -Option    --Default
             charset     undef
             encoding    <depends on type>
             extensions  []
             simplified  <derived from type>
             system      undef
             type        <required>

           charset => $charset
             Specify the default charset for this type.

           encoding => '7bit'|'8bit'|'base64'|'quoted-printable'
             How  must  this  data  be encoded to be transported safely.  The default depends on the type: mimes
             with as main type "text/" will default to "quoted-printable" and all other to "base64".

           extensions => REF-ARRAY
             An array of extensions which are using this mime.

           simplified => STRING
             The mime types main- and sub-label can both start with "x-", to indicate that is  a  non-registered
             name.   Of  course,  after  registration  this flag can disappear which adds to the confusion.  The
             simplified string has the "x-" thingies removed and are translated to lower-case.

           system => REGEX
             Regular expression which defines for which systems this rule is valid.  The  REGEX  is  matched  on
             $^O.

           type => STRING
             The type which is defined here.  It consists of a type and a sub-type, both case-insensitive.  This
             module will return lower-case, but accept upper-case.

   Attributes
       $obj->charset()
           [2.28]  RFC6657  prescribes  that  IANA  registrations for text category types explicitly state their
           default character-set.  MIME-Types contains a manually produced list of these defaults.

           This method may also return "_REQUIRED", when there is no default, or "_FRAMED" when the  charset  is
           determined by the content.

       $obj->encoding()
           Returns the type of encoding which is required to transport data of this type safely.

       $obj->extensions()
           Returns a list of extensions which are known to be used for this mime type.

       $any->simplified( [$string] )
           Returns  the  simplified  mime type for this object or the specified STRING.  Mime type names can get
           officially registered.  Until then, they have to carry an "x-" preamble to indicate that.  Of course,
           after recognition, the "x-" can disappear.  In many cases, we prefer the simplified  version  of  the
           type.

           » example: results of simplified()

             my $mime = MIME::Type->new(type => 'x-appl/x-zip');
             print $mime->simplified;                     # 'appl/zip'

             print $mime->simplified('text/PLAIN');       # 'text/plain'
             print MIME::Type->simplified('x-xyz/x-abc'); # 'xyz/abc'

       $obj->system()
           Returns  the  regular  expression  which  can be used to determine whether this type is active on the
           system where you are working on.

       $obj->type()
           Returns the long type of this object, for instance 'text/plain'

   Knowledge
       $obj->defaultCharset()
           [2.29] As per RFC6657, all "text/*"  types  must  either  specify  a  default  charset  in  its  IANA
           registration, or require the charset parameter.  Non-text types may require a charset as well.

           It is hard to extract this information from the IANA registration files automagically, so is manually
           maintained.

           » example: default charset use

              $charset //= $type->defaultCharset // 'utf-8';

       $obj->equals($string|$mime)
           Compare  this  mime-type  object  with  a  type  as $string or other $mime type object.  In case of a
           $string, simplification will take place.

       $obj->isAscii()
           Old name for isText().

       $obj->isBinary()
           Returns "true" when the type is not known to be text.  See isText().

       $obj->isExperimental()
           [2.00] Return "true" when the type is defined for experimental use; the subtype starts with "x."

       $obj->isPersonal()
           [2.00] Return "true" when the type is defined by a person for private use; the  subtype  starts  with
           "prs."

       $obj->isRegistered()
           Mime-types  which  are  not  registered  by  IANA nor defined in RFCs shall start with an "x-".  This
           counts for as well the media-type as the sub-type.  In case either one of the types starts with  "x-"
           this method will return "false".

       $obj->isSignature()
           Returns "true" when the type is in the list of known signatures.

       $obj->isText()
           [2.05]  All  types  which  may  have the charset attribute, are text.  However, there is currently no
           record of attributes in this module... so we guess.

       $obj->isVendor()
           [2.00] Return "true" when the type is defined by a vendor; the subtype starts with "vnd."

       $obj->mediaType()
           The media type of the simplified mime.  For 'text/plain' it will return 'text'.

           For historical reasons, the 'mainType' method still can be used to retrieve the same value.  However,
           that method is deprecated.

       $obj->subType()
           The sub type of the simplified mime.  For 'text/plain' it will return 'plain'.

DIAGNOSTICS

       Error: Type parameter is obligatory.
           When a MIME::Type object is created, the type itself must be specified with the "type"  option  flag.
           Cast by new()

SEE ALSO

       This   module   is   part   of   MIME-Types   version   2.30,   built  on  December  08,  2025.  Website:
       http://perl.overmeer.net/CPAN/

LICENSE

       For contributors see file ChangeLog.

       This software is copyright (c) 1999-2025 by Mark Overmeer.

       This is free software; you can redistribute it and/or modify it under  the  same  terms  as  the  Perl  5
       programming language system itself.

perl v5.40.1                                       2025-12-08                                    MIME::Type(3pm)