// GENERATED CONTENT - DO NOT EDIT
// Content was automatically extracted by Reffy into reffy-reports
// (https://github.com/tidoust/reffy-reports)
// Source: CSS Regions Module Level 1 (https://drafts.csswg.org/css-regions/)

partial interface Document {
  readonly attribute NamedFlowMap namedFlows;
};

[Exposed=Window,
 MapClass=(CSSOMString, NamedFlow)] interface NamedFlowMap {
  NamedFlow? get(CSSOMString flowName);
  boolean has(CSSOMString flowName);
  NamedFlowMap set(CSSOMString flowName, NamedFlow flowValue);
  boolean delete(CSSOMString flowName);
};

[Exposed=Window]
interface NamedFlow : EventTarget {
  readonly attribute CSSOMString name;
  readonly attribute boolean overset;
  sequence<Region> getRegions();
  readonly attribute short firstEmptyRegionIndex;
  sequence<Node> getContent();
  sequence<Region> getRegionsByContent(Node node);
};

interface mixin Region {
  readonly attribute CSSOMString regionOverset;
  sequence<Range>? getRegionFlowRanges();
};

Element includes Region;
