vendor/spatie/schema-org/src/BreadcrumbList.php line 26

Open in your IDE?
  1. <?php
  3. namespace Spatie\SchemaOrg;
  5. use Spatie\SchemaOrg\Contracts\BreadcrumbListContract;
  6. use Spatie\SchemaOrg\Contracts\IntangibleContract;
  7. use Spatie\SchemaOrg\Contracts\ItemListContract;
  8. use Spatie\SchemaOrg\Contracts\ThingContract;
  10. /**
  11.  * A BreadcrumbList is an ItemList consisting of a chain of linked Web pages,
  12.  * typically described using at least their URL and their name, and typically
  13.  * ending with the current page.
  14.  *
  15.  * The [[position]] property is used to reconstruct the order of the items in a
  16.  * BreadcrumbList. The convention is that a breadcrumb list has an
  17.  * [[itemListOrder]] of [[ItemListOrderAscending]] (lower values listed first),
  18.  * and that the first items in this list correspond to the "top" or beginning of
  19.  * the breadcrumb trail, e.g. with a site or section homepage. The specific
  20.  * values of 'position' are not assigned meaning for a BreadcrumbList, but they
  21.  * should be integers, e.g. beginning with '1' for the first item in the list.
  22.  *
  23.  * @see https://schema.org/BreadcrumbList
  24.  *
  25.  */
  26. class BreadcrumbList extends BaseType implements BreadcrumbListContract, IntangibleContract, ItemListContract, ThingContract
  27. {
  28.     /**
  29.      * An additional type for the item, typically used for adding more specific
  30.      * types from external vocabularies in microdata syntax. This is a
  31.      * relationship between something and a class that the thing is in. In RDFa
  32.      * syntax, it is better to use the native RDFa syntax - the 'typeof'
  33.      * attribute - for multiple types. Schema.org tools may have only weaker
  34.      * understanding of extra types, in particular those defined externally.
  35.      *
  36.      * @param string|string[] $additionalType
  37.      *
  38.      * @return static
  39.      *
  40.      * @see https://schema.org/additionalType
  41.      */
  42.     public function additionalType($additionalType)
  43.     {
  44.         return $this->setProperty('additionalType', $additionalType);
  45.     }
  47.     /**
  48.      * An alias for the item.
  49.      *
  50.      * @param string|string[] $alternateName
  51.      *
  52.      * @return static
  53.      *
  54.      * @see https://schema.org/alternateName
  55.      */
  56.     public function alternateName($alternateName)
  57.     {
  58.         return $this->setProperty('alternateName', $alternateName);
  59.     }
  61.     /**
  62.      * A description of the item.
  63.      *
  64.      * @param string|string[] $description
  65.      *
  66.      * @return static
  67.      *
  68.      * @see https://schema.org/description
  69.      */
  70.     public function description($description)
  71.     {
  72.         return $this->setProperty('description', $description);
  73.     }
  75.     /**
  76.      * A sub property of description. A short description of the item used to
  77.      * disambiguate from other, similar items. Information from other properties
  78.      * (in particular, name) may be necessary for the description to be useful
  79.      * for disambiguation.
  80.      *
  81.      * @param string|string[] $disambiguatingDescription
  82.      *
  83.      * @return static
  84.      *
  85.      * @see https://schema.org/disambiguatingDescription
  86.      */
  87.     public function disambiguatingDescription($disambiguatingDescription)
  88.     {
  89.         return $this->setProperty('disambiguatingDescription', $disambiguatingDescription);
  90.     }
  92.     /**
  93.      * The identifier property represents any kind of identifier for any kind of
  94.      * [[Thing]], such as ISBNs, GTIN codes, UUIDs etc. Schema.org provides
  95.      * dedicated properties for representing many of these, either as textual
  96.      * strings or as URL (URI) links. See [background
  97.      * notes](/docs/datamodel.html#identifierBg) for more details.
  98.      *
  99.      * @param \Spatie\SchemaOrg\Contracts\PropertyValueContract|\Spatie\SchemaOrg\Contracts\PropertyValueContract[]|string|string[] $identifier
  100.      *
  101.      * @return static
  102.      *
  103.      * @see https://schema.org/identifier
  104.      */
  105.     public function identifier($identifier)
  106.     {
  107.         return $this->setProperty('identifier', $identifier);
  108.     }
  110.     /**
  111.      * An image of the item. This can be a [[URL]] or a fully described
  112.      * [[ImageObject]].
  113.      *
  114.      * @param \Spatie\SchemaOrg\Contracts\ImageObjectContract|\Spatie\SchemaOrg\Contracts\ImageObjectContract[]|string|string[] $image
  115.      *
  116.      * @return static
  117.      *
  118.      * @see https://schema.org/image
  119.      */
  120.     public function image($image)
  121.     {
  122.         return $this->setProperty('image', $image);
  123.     }
  125.     /**
  126.      * For itemListElement values, you can use simple strings (e.g. "Peter",
  127.      * "Paul", "Mary"), existing entities, or use ListItem.
  128.      *
  129.      * Text values are best if the elements in the list are plain strings.
  130.      * Existing entities are best for a simple, unordered list of existing
  131.      * things in your data. ListItem is used with ordered lists when you want to
  132.      * provide additional context about the element in that list or when the
  133.      * same item might be in different places in different lists.
  134.      *
  135.      * Note: The order of elements in your mark-up is not sufficient for
  136.      * indicating the order or elements.  Use ListItem with a 'position'
  137.      * property in such cases.
  138.      *
  139.      * @param \Spatie\SchemaOrg\Contracts\ListItemContract|\Spatie\SchemaOrg\Contracts\ListItemContract[]|\Spatie\SchemaOrg\Contracts\ThingContract|\Spatie\SchemaOrg\Contracts\ThingContract[]|string|string[] $itemListElement
  140.      *
  141.      * @return static
  142.      *
  143.      * @see https://schema.org/itemListElement
  144.      */
  145.     public function itemListElement($itemListElement)
  146.     {
  147.         return $this->setProperty('itemListElement', $itemListElement);
  148.     }
  150.     /**
  151.      * Type of ordering (e.g. Ascending, Descending, Unordered).
  152.      *
  153.      * @param \Spatie\SchemaOrg\Contracts\ItemListOrderTypeContract|\Spatie\SchemaOrg\Contracts\ItemListOrderTypeContract[]|string|string[] $itemListOrder
  154.      *
  155.      * @return static
  156.      *
  157.      * @see https://schema.org/itemListOrder
  158.      */
  159.     public function itemListOrder($itemListOrder)
  160.     {
  161.         return $this->setProperty('itemListOrder', $itemListOrder);
  162.     }
  164.     /**
  165.      * Indicates a page (or other CreativeWork) for which this thing is the main
  166.      * entity being described. See [background
  167.      * notes](/docs/datamodel.html#mainEntityBackground) for details.
  168.      *
  169.      * @param \Spatie\SchemaOrg\Contracts\CreativeWorkContract|\Spatie\SchemaOrg\Contracts\CreativeWorkContract[]|string|string[] $mainEntityOfPage
  170.      *
  171.      * @return static
  172.      *
  173.      * @see https://schema.org/mainEntityOfPage
  174.      */
  175.     public function mainEntityOfPage($mainEntityOfPage)
  176.     {
  177.         return $this->setProperty('mainEntityOfPage', $mainEntityOfPage);
  178.     }
  180.     /**
  181.      * The name of the item.
  182.      *
  183.      * @param string|string[] $name
  184.      *
  185.      * @return static
  186.      *
  187.      * @see https://schema.org/name
  188.      */
  189.     public function name($name)
  190.     {
  191.         return $this->setProperty('name', $name);
  192.     }
  194.     /**
  195.      * The number of items in an ItemList. Note that some descriptions might not
  196.      * fully describe all items in a list (e.g., multi-page pagination); in such
  197.      * cases, the numberOfItems would be for the entire list.
  198.      *
  199.      * @param int|int[] $numberOfItems
  200.      *
  201.      * @return static
  202.      *
  203.      * @see https://schema.org/numberOfItems
  204.      */
  205.     public function numberOfItems($numberOfItems)
  206.     {
  207.         return $this->setProperty('numberOfItems', $numberOfItems);
  208.     }
  210.     /**
  211.      * Indicates a potential Action, which describes an idealized action in
  212.      * which this thing would play an 'object' role.
  213.      *
  214.      * @param \Spatie\SchemaOrg\Contracts\ActionContract|\Spatie\SchemaOrg\Contracts\ActionContract[] $potentialAction
  215.      *
  216.      * @return static
  217.      *
  218.      * @see https://schema.org/potentialAction
  219.      */
  220.     public function potentialAction($potentialAction)
  221.     {
  222.         return $this->setProperty('potentialAction', $potentialAction);
  223.     }
  225.     /**
  226.      * URL of a reference Web page that unambiguously indicates the item's
  227.      * identity. E.g. the URL of the item's Wikipedia page, Wikidata entry, or
  228.      * official website.
  229.      *
  230.      * @param string|string[] $sameAs
  231.      *
  232.      * @return static
  233.      *
  234.      * @see https://schema.org/sameAs
  235.      */
  236.     public function sameAs($sameAs)
  237.     {
  238.         return $this->setProperty('sameAs', $sameAs);
  239.     }
  241.     /**
  242.      * A CreativeWork or Event about this Thing.
  243.      *
  244.      * @param \Spatie\SchemaOrg\Contracts\CreativeWorkContract|\Spatie\SchemaOrg\Contracts\CreativeWorkContract[]|\Spatie\SchemaOrg\Contracts\EventContract|\Spatie\SchemaOrg\Contracts\EventContract[] $subjectOf
  245.      *
  246.      * @return static
  247.      *
  248.      * @see https://schema.org/subjectOf
  249.      * @link https://github.com/schemaorg/schemaorg/issues/1670
  250.      */
  251.     public function subjectOf($subjectOf)
  252.     {
  253.         return $this->setProperty('subjectOf', $subjectOf);
  254.     }
  256.     /**
  257.      * URL of the item.
  258.      *
  259.      * @param string|string[] $url
  260.      *
  261.      * @return static
  262.      *
  263.      * @see https://schema.org/url
  264.      */
  265.     public function url($url)
  266.     {
  267.         return $this->setProperty('url', $url);
  268.     }
  269. }