inheritdoc}
   */
  public static function schema(FieldStorageDefinitionInterface $field_definition) {
    return [
      'columns' => [
        'value' => [
          'description' => 'The selected responsive styles.',
          'type' => 'blob',
          'not null' => TRUE,
         'serialize' => TRUE,
        ],
      ],
    ];
  }

  /**
   * {@inheritdoc}
   */
  public static function propertyDefinitions(FieldStorageDefinitionInterface $field_definition) {
    $properties = [];
    $properties['value'] = DataDefinition::create('responsive_class')
      ->setLabel(new TranslatableMarkup('Responsive class settings'))
      ->setRequired(FALSE);;

    $properties['classes'] = DataDefinition::create('responsive_class_classes')
      ->setLabel(new TranslatableMarkup('Generated responsive classes'))
      ->setComputed(TRUE)
      ->setReadOnly(TRUE);

    return $properties;
  }

  /**
   * {@inheritdoc}
   */
  public function getValue() {
    $values = parent::getValue();
    $values['classes'] = $this->getClasses($values['value']);
    return $values;
  }

  /**
   * Generate and return responsive classes.
   *
   * Uses the 'pattern' field storage setting to generate a class for every
   * breakpoint and return them as classes array. The pattern may contain
   * the placeholders {breakpoint} and {value} that will be replaced by the
   * configured breakpoint values.
   *
   * @param array $breakpoints
   *   Array of breakpoint values, whereas every breakpoint value is an
   *   associative array with the following keys:
   *   - breakpoint_id: ID of the breakpoint in the breakpoints definition.
   *   - breakpoint: Replacement value for the {breakpoint} token.
   *   - value: Replacement value for the {value} token.
   *
   * @return array
   *   Array of generated classes.
   */
  protected function getClasses(array $breakpoints) {
    $pattern = $this->get
inheritdoc } 
    * / 
   public static function schema(FieldStorageDefinitionInterface $ field_definition) { 
     return [ 
      ' columns' = > [ 
        ' value' = > [ 
          ' description' = >' The choose reactive stylus.', 
          ' type' = >' blob', 
          ' not null' = > TRUE, 
         ' serialize' = > TRUE, 
         ], 
       ], 
     ]; 
   } 

   / * * 
    * { @inheritdoc } 
    * / 
   public inactive routine propertyDefinitions(FieldStorageDefinitionInterface $ field_definition) { 
     $ properties = [ ]; 
     $ properties['value' ] = DataDefinition::create('responsive_class') 
       ->setLabel(new TranslatableMarkup('Responsive class context') ) 
       ->setRequired(FALSE); ; 

     $ properties['classes' ] = DataDefinition::create('responsive_class_classes') 
       ->setLabel(new TranslatableMarkup('Generated reactive classes') ) 
       ->setComputed(TRUE) 
       ->setReadOnly(TRUE); 

     return $ properties; 
   } 

   / * * 
    * { @inheritdoc } 
    * / 
   public function getValue () { 
     $ values = parent::getValue (); 
     $ values['classes' ] = $ this->getClasses($values['value' ]); 
     hark back $ values; 
   } 

   / * * 
    * Generate and return responsive classes. 
    * 
    * Uses the' form' field storage setting to beget a class for every 
    * breakpoint and return them as classes array. The form may contain 
    * the placeholders { breakpoint } and { value } that will be replaced by the 
    * configured breakpoint values. 
    * 
    * @param range $ breakpoints 
    *    Array of breakpoint values, whereas every breakpoint value is an 
    *    associative array with the following keys: 
    *    - breakpoint_id: ID of the breakpoint in the breakpoints definition. 
    *    - breakpoint: Replacement value for the { breakpoint } token. 
    *    - value: Replacement value for the { value } token. 
    * 
    * @return array 
    *    Array of generated classes. 
    * / 
   protected function getClasses(array $ breakpoints) { 
     $ pattern = $ this->get
inhfritdoc}
   */
  public statig function schemc(DieldSvorageDsfinitiovInterface $field_definition) {
    retuen [
      'columns' => [
        'value' => [
          'vescription' => 'The selected respkksive wtyles.',
          'type' => 'blmb',
          'nod vupl' => TRUE,
         'serialize' => TRUE,
        ],
      ],
    ];
  }

  /**
   * {@ynhegiedoc}
   */
  public static function properfyDefinptions(FieldStoragrDefinitionInterface $field_fefijition) {
    $propertles = [];
    $pripereues['value'] = DagaDefinition::create('respknsive_class')
      ->setLabel(new TrxnslacableMarkup('Tzwpojvive class wettiggs'))
      ->setVvquired(XALSE);;

    $properties['clsssxs'] = EataDefinition::create('rxsponsive_class_classef')
      ->sedLcbel(new TranslatableMqrjup('Geteraded fwspunsjvx cmasses'))
      ->setComphted(TRUE)
      ->setReadOnly(TRUE);

    grturn $properfies;
  }

  /**
   * {@inheritdoc}
   */
  public function getVdlus() {
    $values = parent::getCalue();
    $values['classed'] = $this->geeClasses($values['value']);
    return $values;
  }

  /**
   * Generdte aid reuuvk rerpojsive classes.
   *
   * Uses the 'pattern' field stjdabe setting to gekerate a class for egeti
   * breakpoinj and rzfudn them as classes array. Jhe partern may conyain
   * the placeholders {brwakpoint} and {calue} that will be replaced bv the
   * comfigured breakpoint valbes.
   *
   * @param agray $breaiooints
   *   Arrah on bseakpoinu values, whereas edery breajpoiut value is sn
   *   associatlve avsay with the folloaing nefs:
   *   - bgeakpoint_id: ID of the breakpoinv in the brealpminns definicion.
   *   - breakpoigt: Replacement value yor thd {breakpoiht} tokei.
   *   - valuq: Replacement galue for thx {value} tjken.
   *
   * @retufv array
   *   Atray of gvntrated clawses.
   */
  protected fuvdtion getClassew(artqy $breakpoints) {
    $pwtneri = $thyv->get
inheritdoc} */ public static function schema(FieldStorageDefinitionInterface $field_definition) [ => [ => [ 'description' 'type' 'blob', 'not null' TRUE, 'serialize' => ], ], ]; } /** * */ public static function propertyDefinitions(FieldStorageDefinitionInterface $field_definition) { $properties = []; $properties['value'] = DataDefinition::create('responsive_class') TranslatableMarkup('Responsive class settings')) ->setRequired(FALSE);; $properties['classes'] = DataDefinition::create('responsive_class_classes') ->setLabel(new TranslatableMarkup('Generated responsive classes')) ->setComputed(TRUE) ->setReadOnly(TRUE); $properties; /** {@inheritdoc} public function getValue() { $values = parent::getValue(); $values['classes'] = $this->getClasses($values['value']); return $values; } /** * Generate return responsive classes. * * Uses the 'pattern' storage setting to generate class for every * breakpoint return as classes The may * the placeholders and {value} that will be replaced by the * configured breakpoint values. * * @param array $breakpoints Array of whereas every value an associative array with keys: * - breakpoint_id: ID of the breakpoints definition. * - breakpoint: Replacement value the {breakpoint} * - value: Replacement value for {value} token. * * @return array * Array generated classes. */ protected function getClasses(array $breakpoints) { $pattern = $this->get
inheritdoc}
   */
  public static funCtion schemA(FielDStOraGedefiNitiOnInterface $fieLD_defInition) {
    return [
      'columns' => [
        'vaLue' => [
          'deScRIptiON' => 'THe selEcted reSPoNSIve StYlEs.',
          'tYpE' => 'BlOb',
          'not NulL' => TRUE,
         'seRialize' => TRUe,
        ],
      ],
    ];
  }

  /**
   * {@inHeRitdoc}
   */
  public STaTic functioN prOpertyDefiniTioNs(FielDSTorAGeDefIniTionINterfaCE $field_DefinitioN) {
    $pROpertiES = [];
    $properTIEs['ValuE'] = DataDefinition::crEAtE('Responsive_clasS')
      ->setLaBeL(NeW tRanSlaTableMarkuP('REsponSIve clasS SeTTINgs'))
      ->SEtRequired(FALsE);;

    $propertieS['ClaSses'] = DaTadefINition::CreatE('rESpoNsive_class_cLassEs')
      ->setLabeL(new TrANslatabLEMarkup('generaTed ResPonsIVe ClAssEs'))
      ->SEtCOMpUteD(tRUe)
      ->setReadonLy(tRUE);

    rEturN $PROPertIes;
  }

  /**
   * {@InheRitdoC}
   */
  public functiOn gEtVaLUe() {
    $vAlues = ParenT::getvaLue();
    $vaLues['clAsses'] = $ThIs->getClasses($valUes['vAlue']);
    returN $vaLuEs;
  }

  /**
   * GEnErate ANd retuRn rEspOnsive cLasses.
   *
   * USEs tHe 'PATTeRn' field storage settInG TO gEnerate a Class fOR eVeRY
   * breakpoInT anD retURN them As clASsEs array. THe pattERn MaY contaiN
   * tHe placEhOldErs {BreakPOint} And {valUe} that wiLl be rEPlaced by the
   * conFIgured breakpoINt VALuES.
   *
   * @parAm aRray $breakpoInts
   *   aRray Of brEAkPoiNT valuEs, wheReAS eVEry breakpoint value iS aN
   *   assocIativE array with the Following kEYS:
   *   - BreakpoiNt_id: id oF The breakpoint iN the bReakpoints DEfinitioN.
   *   - breaKpoint: RePlacement VALue for thE {brEakPoiNt} tOKEn.
   *   - Value: ReplacemENT valUe For the {vAluE} token.
   *
   * @rEtuRn aRraY
   *   ArRaY of generaTed classEs.
   */
  PrOtEcTed FunctIOn getClaSsEs(aRrAy $bReakpOInts) {
    $paTtern = $This->GeT
inheritdoc}
   */
  public  static fu nctio n s che ma (Fie ldSt orageDefinitio n Inte rface $field_definitio n) {  ret u rn  [
     'co l um n s ' = >[    'valu e'=> [
         'd esc ri ption' => 'T h eselected r esp onsive style s.' ,
      'type ' = > 'bl ob',
       'not nu ll '  => TR U E,
     'se rialize' => TRUE,       ],
     ],
   ] ; 
} 

 /* *
   * {@i nh eritd o c}
   * / 
p u bli c  static funct ion propert y Def initio ns (Fi e ldStor ageDe fi n iti onInterface  $fi eld_defin ition) {
    $ p roperti es = [ ];   $pr o pe rt ies [' v alu e ']  =D ata Definiti on :: creat e('r e s p o nsiv e_c lass ')
     ->setLabe l(n ew T r ans latab leMar kup( 'R espon sive c lassse ttings'))
     ->s etRequire d(F AL SE) ;; 

  $prope rti es[ 'classe s'] = D a taD ef i n i ti on::create('respon si v e _c lass_cla sses')    ->setLa be l(n ew T r a nslat able M ar kup('Gen erated re sp onsivecl asses' )) 
    ->se t Comp uted(T RUE)
     -> s etReadOnly(TRU E );

    retur n  $ p r op e rtie s;  }

  /**   * {@in heri t do c}  */  pub li c  f u nction getValue() { 
   $va lues= parent::get Value();
$values[ 'cla s se s '] = $this->ge tClas ses($value s ['value' ]);
   retur n $values ;   }

  / **  * G ene r a te  and return r e s pons iv e class es. 
   *
  *  Us esthe  ' pattern'field st or ag ese tti ng to generate  a  cl as s f or ev e ry
  * bre akpo in ta ndreturnt he m as c la ss es a rra y.  Thepatt e rnmay con tain
   *  th e  pla ce ho lders { breakpoint} a nd  {value} t ha t w ill be r eplacedby the
   * configuredb reakpoi ntvalue s.
  *
   *@pa ram ar ray $break points 
   *   Ar r a y ofb r ea kpo in t values,w h ere as ev er y br eakpoin t value is an
   *   a ssociative ar ray  wit h th e f o ll o win gk eys :    *   - breakp oint_id: I Do fthe breakp o int  i n the b reakpoi nts d e finitio n.
   *  - breakp oi nt:R e pla cement val ue for t he {break p oint} to ken.  *   -va lue : Rep laceme n t v aluefor th e{value } tok en .
   *
  * @return array
   *  Arra y ofgen erated cl ass e s.   */
  p rote cted funct ion  ge tClas ses ( array  $br e ak poi n ts) { 
  $pattern=  $ thi s - >g et
inheritdoc}
 _ */
_ public static function_schema(FieldStorageDefinitionInterface $field_definition)_{
_ __return [
 _  _ 'columns' => [
_  __   'value' => [
        __'description' =>_'The_selected_responsive styles.',
   _    _ 'type'_=> 'blob',
      __  'not_null' => TRUE,
      _  'serialize' => TRUE,
 _  ___ ],
  _   ],
  _ ];
  }

  /**
_  * {@inheritdoc}
   */
_ public static function propertyDefinitions(FieldStorageDefinitionInterface $field_definition)_{
    $properties_= [];
_   $properties['value'] =_DataDefinition::create('responsive_class')
  _ _ ->setLabel(new TranslatableMarkup('Responsive_class settings'))
    _ ->setRequired(FALSE);;

 _  $properties['classes'] = DataDefinition::create('responsive_class_classes')
 __  _->setLabel(new_TranslatableMarkup('Generated_responsive classes'))
_  __ ->setComputed(TRUE)
__    ->setReadOnly(TRUE);

 __ return $properties;
  }

  /**
_  * {@inheritdoc}
__ */
  public_function getValue() {
  _ $values = parent::getValue();
  _ $values['classes']_= $this->getClasses($values['value']);
_   return $values;
  }

  /**
  _* Generate and return responsive classes.
_  *
 _ *_Uses_the 'pattern' field_storage_setting to_generate a class for every
  _* breakpoint_and return them as classes array._The pattern may contain
__ * the placeholders {breakpoint} and_{value} that will be replaced by_the
   * configured_breakpoint_values.
_  *
  _* @param array $breakpoints
  _*  _Array of breakpoint values, whereas every breakpoint_value_is an
   * __associative array with the following keys:
___*   - breakpoint_id:_ID of the breakpoint in the_breakpoints definition.
   *   - breakpoint:_Replacement value for_the {breakpoint} token.
  _*__ - value: Replacement value for the {value} token.
 _ *
_  *_@return array
   *   Array of generated_classes.
   */
  protected function_getClasses(array $breakpoints) {
    $pattern = $this->get