sketchup-api-stubs 0.1.2 → 0.2.0

data/SketchUp/Layout/Group.rb

@@ -0,0 +1,261 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# A group is a special type of {Layout::Entity} that does not belong to a
+# {Layout::Layer} and contains other {Layout::Entity}s as children. A
+# {Layout::Group}'s children may include other {Layout::Group}s, allowing for a
+# hierarchical tree structure of {Layout::Entity}s. A {Layout::Group} must
+# contain at least one child and will be automatically collapsed if an
+# operation is performed that results in the {Layout::Group} being empty.
+#
+# @version LayOut 2018
+class Layout::Group < Layout::Entity
+
+  # Constants
+
+  RESIZE_BEHAVIOR_BOUNDS = nil # Stub value.
+  RESIZE_BEHAVIOR_BOUNDS_AND_FONTS = nil # Stub value.
+  RESIZE_BEHAVIOR_NONE = nil # Stub value.
+
+  # Instance Methods
+
+  # The {#entities} method returns the {Layout::Entities} that belong to the
+  # {Layout::Group}.
+  #
+  # @example
+  #   doc = Layout::Document.open("C:/path/to/document.layout")
+  #   group = doc.shared_entities.first
+  #   entities = group.entities
+  #
+  # @return [Layout::Entities]
+  #
+  # @version LayOut 2018
+  def entities
+  end
+
+  # The {#initialize} method creates a new {Layout::Group}.
+  #
+  # @example
+  #   doc = Layout::Document.open("C:/path/to/document.layout")
+  #   entities = doc.shared_entities
+  #   entities.each { |entity|
+  #     entity_array.push(entity)
+  #   }
+  #   group = Layout::Group.new(entity_array)
+  #
+  # @param [Array<Layout::Entity>] entities
+  #
+  # @raise [ArgumentError] if entities is empty.
+  #
+  # @raise [ArgumentError] if entities contains the same {Layout::Entity} more
+  #   than once
+  #
+  # @raise [ArgumentError] if entities contains {Layout::Entity}s on both shared
+  #   and non-shared {Layout::Layer}s, or on non-shared {Layout::Layer}s
+  #   belonging to different {Layout::Page}s
+  #
+  # @raise [ArgumentError] if entities contains a mix of {Layout::Entity}s that
+  #   belong to a {Layout::Document} and {Layout::Entity}s that don't belong to a
+  #   {Layout::Document}
+  #
+  # @raise [ArgumentError] if entities contains {Layout::Entity}s that belong to
+  #   different {Layout::Document}s
+  #
+  # @return [Layout::Group]
+  #
+  # @version LayOut 2018
+  def initialize(entities)
+  end
+
+  # The {#remove_scale_factor} method removes the scale factor from the
+  # {Layout::Group}.
+  #
+  # The resize behavior can be one of the following values:
+  # [+Layout::Group::RESIZE_BEHAVIOR_NONE+]
+  # [+Layout::Group::RESIZE_BEHAVIOR_BOUNDS+]
+  # [+Layout::Group::RESIZE_BEHAVIOR_BOUNDS_AND_FONTS+]
+  #
+  # @example
+  #   doc = Layout::Document.open("C:/path/to/document.layout")
+  #   group = doc.shared_entities.first
+  #   group.remove_scale_factor(true)
+  #
+  # @param [Integer] resize_behavior
+  #
+  # @raise [ArgumentError] if the {Layout::Group} does not have a scale factor
+  #
+  # @raise [Layout::LockedLayerError] if the {Layout::Group} is on a locked layer
+  #
+  # @raise [Layout::LockedEntityError] if the {Layout::Group} is locked
+  #
+  # @version LayOut 2018
+  def remove_scale_factor(resize_behavior)
+  end
+
+  # The {#scale_factor} method returns the the scale factor associated with the
+  # {Layout::Group}.
+  #
+  # @example
+  #   doc = Layout::Document.open("C:/path/to/document.layout")
+  #   group = doc.shared_entities.first
+  #   scale = group.scale_factor
+  #
+  # @return [Float, nil]
+  #
+  # @version LayOut 2018
+  def scale_factor
+  end
+
+  # The {#scale_precision} method returns the precision used for the scale of the
+  # {Layout::Group}.
+  #
+  # @example
+  #   doc = Layout::Document.open("C:/path/to/document.layout")
+  #   group = doc.shared_entities.first
+  #   precision = group.scale_precision
+  #
+  # @return [Float] the number specifying the precision for the {Layout::Group}
+  #
+  # @version LayOut 2018
+  def scale_precision
+  end
+
+  # The {#scale_precision=} method sets the precision for the scale of the
+  # {Layout::Group}.
+  #
+  # @example
+  #   doc = Layout::Document.open("C:/path/to/document.layout")
+  #   group = doc.shared_entities.first
+  #   group.scale_precision = 0.0001
+  #
+  # @note LayOut only allows for a finite set of precision values for each units
+  #   setting, so it will set the precision to the closest valid setting for the
+  #   specified units. See the "Units" section of LayOut's "Document Setup"
+  #   dialog for a reference of the available precisions for each units setting.
+  #
+  # @param [Float] precision
+  #   The double specifying the precision for the
+  #   {Layout::Group}
+  #
+  # @version LayOut 2018
+  def scale_precision=(precision)
+  end
+
+  # The {#scale_units} method returns the units format used in the scale for the
+  # {Layout::Group}.
+  #
+  # The units format can be any of the following values:
+  # [Layout::Document::FRACTIONAL_INCHES]
+  # [Layout::Document::DECIMAL_INCHES]
+  # [Layout::Document::DECIMAL_FEET]
+  # [Layout::Document::DECIMAL_MILLIMETERS]
+  # [Layout::Document::DECIMAL_CENTIMETERS]
+  # [Layout::Document::DECIMAL_METERS]
+  # [Layout::Document::DECIMAL_POINTS]
+  #
+  # @example
+  #   doc = Layout::Document.open("C:/path/to/document.layout")
+  #   group = doc.shared_entities.first
+  #   units = group.scale_units
+  #
+  # @raise [ArgumentError] if the {Layout::Group} does not have a scale factor
+  #
+  # @return [Integer] units The units format of the scale factor
+  #
+  # @version LayOut 2018
+  def scale_units
+  end
+
+  # The {#scale_units=} method sets the the units format for the scale of the
+  # {Layout::Group}.
+  #
+  # The units format can be any of the following values:
+  # [Layout::Document::FRACTIONAL_INCHES]
+  # [Layout::Document::DECIMAL_INCHES]
+  # [Layout::Document::DECIMAL_FEET]
+  # [Layout::Document::DECIMAL_MILLIMETERS]
+  # [Layout::Document::DECIMAL_CENTIMETERS]
+  # [Layout::Document::DECIMAL_METERS]
+  # [Layout::Document::DECIMAL_POINTS]
+  #
+  # @example
+  #   doc = Layout::Document.open("C:/path/to/document.layout")
+  #   group = doc.shared_entities.first
+  #   group.scale_units = Layout::Document::DECIMAL_FEET
+  #
+  # @param [Integer] units_format
+  #
+  # @raise [ArgumentError] if the {Layout::Group} does not have a scale factor
+  #
+  # @raise [ArgumentError] if scale_units is not a valid value
+  #
+  # @raise [Layout::LockedLayerError] if the {Layout::Group} is on a locked layer
+  #
+  # @raise [Layout::LockedEntityError] if the {Layout::Group} is locked
+  #
+  # @version LayOut 2018
+  def scale_units=(units_format)
+  end
+
+  # The {#set_scale_factor} method sets the the scale factor for the
+  # {Layout::Group}.
+  #
+  # The units format can be any of the following values:
+  # [Layout::Document::FRACTIONAL_INCHES]
+  # [Layout::Document::DECIMAL_INCHES]
+  # [Layout::Document::DECIMAL_FEET]
+  # [Layout::Document::DECIMAL_MILLIMETERS]
+  # [Layout::Document::DECIMAL_CENTIMETERS]
+  # [Layout::Document::DECIMAL_METERS]
+  # [Layout::Document::DECIMAL_POINTS]
+  #
+  # The resize behavior can be one of the following values:
+  # [+Layout::Group::RESIZE_BEHAVIOR_NONE+]
+  # [+Layout::Group::RESIZE_BEHAVIOR_BOUNDS+]
+  # [+Layout::Group::RESIZE_BEHAVIOR_BOUNDS_AND_FONTS+]
+  #
+  # @example
+  #   doc = Layout::Document.open("C:/path/to/document.layout")
+  #   group = doc.shared_entities.first
+  #   group.set_scale_factor(2.0, Layout::Group::RESIZE_BEHAVIOR_BOUNDS)
+  #
+  # @param [Integer] units_format
+  #
+  # @param [Float] scale_factor
+  #
+  # @param [Integer] resize_behavior
+  #
+  # @raise [LockedLayerError] if the {Layout::Group} is on a locked
+  #   {Layout::Layer}
+  #
+  # @raise [ArgumentError] if a scale factor cannot be set for the
+  #   {Layout::Group}
+  #
+  # @raise [ArgumentError] if scale_factor is an invalid value
+  #
+  # @raise [ArgumentError] if the {Layout::Group} cannot be assigned a scale
+  #   factor because it is already inheriting a scale factor from its parent
+  #
+  # @raise [LockedEntityError] if the {Layout::Group} is locked
+  #
+  # @version LayOut 2018
+  def set_scale_factor(scale_factor, units_format, resize_behavior)
+  end
+
+  # The {#ungroup} method removes all {Layout::Entity}s from the {Layout::Group}
+  # and deletes the {Layout::Group}.
+  #
+  # @example
+  #   doc = Layout::Document.open("C:/path/to/document.layout")
+  #   group = doc.shared_entities.first
+  #   group.ungroup
+  #
+  # @raise [LockedEntityError] if the {Layout::Group} is locked
+  #
+  # @return [Boolean]
+  #
+  # @version LayOut 2018
+  def ungroup
+  end
+
+end

data/SketchUp/Layout/Image.rb

@@ -0,0 +1,86 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# A raster image entity.
+#
+# @example
+#   image = Layout::Image.new("my_image.png", [[1, 1], [3, 3]])
+#   clip_mask = image.clip_mask
+#   if clip_mask.is_a?(Layout::Rectangle)
+#     point1 = Geom::Point2d.new(1, 1)
+#     point2 = Geom::Point2d.new(2, 2)
+#     bounds = [point1, point2]
+#     image.clip_mask = Layout::Ellipse.new(bounds)
+#   end
+#
+# @version LayOut 2018
+class Layout::Image < Layout::Entity
+
+  # Instance Methods
+
+  # The {#clip_mask} method returns the clip mask of the {Layout::Image}, or
+  # +nil+ if it does not have a clip mask.
+  #
+  # @example
+  #   image = Layout::Image.new("my_image.png", [[1, 1], [3, 3]])
+  #   clip_mask = image.clip_mask
+  #
+  # @return [Layout::Entity] The clip mask can be a {Layout::Path},
+  #   {Layout::Rectangle}, or {Layout::Ellipse}.
+  #
+  # @version LayOut 2018
+  def clip_mask
+  end
+
+  # The {#clip_mask=} method sets the clip mask of the {Layout::Image}.
+  #
+  # @example
+  #   image = Layout::Image.new("my_image.png", [[1, 1], [3, 3]])
+  #   point1 = Geom::Point2d.new(1, 1)
+  #   point2 = Geom::Point2d.new(2, 2)
+  #   bounds = [point1, point2]
+  #   clip_mask = Layout::Rectangle.new(bounds)
+  #   image.clip_mask = clip_mask
+  #
+  # @param [Layout::Entity] clip_mask
+  #   The clip mask can be a {Layout::Path},
+  #   {Layout::Rectangle}, {Layout::Ellipse}, or +nil+.
+  #
+  # @raise [ArgumentError] if clip mask is already in a document
+  #
+  # @raise [LockedEntityError] if the {Layout::Image} is locked
+  #
+  # @raise [LockedLayerError] if the {Layout::Image} is on a locked {Layout::Layer}
+  #
+  # @raise [ArgumentError] if clip mask is not a {Layout::Path},
+  #   {Layout::Rectangle}, or {Layout::Ellipse}
+  #
+  # @version LayOut 2018
+  def clip_mask=(clip_mask)
+  end
+
+  # The {#initialize} method creates a new {Layout::Image} from a given image
+  # file.
+  #
+  # @example
+  #   image = Layout::Image.new("my_image.png", [[1, 1], [3, 3]])
+  #
+  # @param [String] path
+  #   The path to the file
+  #
+  # @param [Geom::Bounds2d] bounds
+  #
+  # @raise [ArgumentError] if bounds are zero size
+  #
+  # @raise [RuntimeError] if there was an error allocating memory for the image
+  #
+  # @raise [ArgumentError] if there was an error reading the image file, such as
+  #   the file name being invalid
+  #
+  # @return [Layout::Image]
+  #
+  # @version LayOut 2018
+  def initialize(path, bounds)
+  end
+
+end

data/SketchUp/Layout/Label.rb

@@ -0,0 +1,371 @@
+# Copyright:: Copyright 2017 Trimble Inc.
+# License:: The MIT License (MIT)
+
+# This is an interface to a label entity. A {Layout::Label} consists of a
+# {Layout::FormattedText} and the label leader {Layout::Path}. A
+# {Layout::Label} may be connected to another {Layout::Entity} via a
+# {Layout::ConnectionPoint}.
+#
+# @version LayOut 2018
+class Layout::Label < Layout::Entity
+
+  # Constants
+
+  CONNECTION_TYPE_AUTO = nil # Stub value.
+  CONNECTION_TYPE_BOTTOM_LEFT = nil # Stub value.
+  CONNECTION_TYPE_BOTTOM_RIGHT = nil # Stub value.
+  CONNECTION_TYPE_CENTER_LEFT = nil # Stub value.
+  CONNECTION_TYPE_CENTER_RIGHT = nil # Stub value.
+  CONNECTION_TYPE_NONE = nil # Stub value.
+  CONNECTION_TYPE_REVERSE_AUTO = nil # Stub value.
+  CONNECTION_TYPE_TOP_LEFT = nil # Stub value.
+  CONNECTION_TYPE_TOP_RIGHT = nil # Stub value.
+
+  LEADER_LINE_TYPE_BEZIER = nil # Stub value.
+  LEADER_LINE_TYPE_SINGLE_SEGMENT = nil # Stub value.
+  LEADER_LINE_TYPE_TWO_SEGMENT = nil # Stub value.
+  LEADER_LINE_TYPE_UNKNOWN = nil # Stub value.
+
+  # Instance Methods
+
+  # The {#connect} method connects the {Layout::Label} to the given
+  # {Layout::ConnectionPoint}. The leader line will be adjusted to point at the
+  # {Layout::ConnectionPoint}. The {Layout::Label} must be in the same
+  # {Layout::Document} as the {Layout::ConnectionPoint}. If both the
+  # {Layout::Label} and the {Layout::ConnectionPoint}'s {Layout::Entity} are on
+  # non-shared {Layout::Layer}s, they must be on the same {Layout::Page}.
+  #
+  # @example
+  #   text = "A label"
+  #   leader_type = Layout::Label::LEADER_LINE_TYPE_BEZIER
+  #   target_point = Geom::Point2d.new(1, 1)
+  #   bounds = Geom::Bounds2d.new(2, 1, 1, 1)
+  #   label = Layout::Label.new(text, leader_type, target_point, bounds)
+  #   rect = Layout::Rectangle.new([4, 4, 4, 4])
+  #
+  #   doc = Layout::Document.new
+  #   doc.add_entity(label, doc.layers.first, doc.pages.first)
+  #   doc.add_entity(rect, doc.layers.first, doc.pages.first)
+  #
+  #   point = Geom::Point2d.new(4, 4)
+  #   # Create a Connection Point to a LayOut Entity in the Document
+  #   cp = Layout::ConnectionPoint.new(rect, point)
+  #   label.connect(cp)
+  #
+  # @param [Layout::ConnectionPoint] connection_point
+  #
+  # @raise [LockedLayerError] if the {Layout::Label} is on a locked
+  #   {Layout::Layer}
+  #
+  # @raise [ArgumentError] if both the {Layout::Label} and the
+  #   {Layout::ConnectionPoint} are on non-shared {Layout::Layers}, but are not
+  #   on the same {Layout::Page}.
+  #
+  # @raise [ArgumentError] if the {Layout::Label} is not in the same
+  #   {Layout::Document} as the {Layout::ConnectionPoint}
+  #
+  # @raise [LockedEntityError] if the {Layout::Label} is locked
+  #
+  # @version LayOut 2018
+  def connect(connection_point)
+  end
+
+  # The {#connection_type} method returns the type of the text connection for the
+  # {Layout::Label}.
+  #
+  # The leader line type can be one of the following values:
+  # [+Layout::Label::CONNECTION_TYPE_NONE+]
+  # [+Layout::Label::CONNECTION_TYPE_AUTO+]
+  # [+Layout::Label::CONNECTION_TYPE_REVERSE_AUTO+]
+  # [+Layout::Label::CONNECTION_TYPE_TOP_LEFT+]
+  # [+Layout::Label::CONNECTION_TYPE_CENTER_LEFT+]
+  # [+Layout::Label::CONNECTION_TYPE_BOTTOM_LEFT+]
+  # [+Layout::Label::CONNECTION_TYPE_TOP_RIGHT+]
+  # [+Layout::Label::CONNECTION_TYPE_CENTER_RIGHT+]
+  # [+Layout::Label::CONNECTION_TYPE_BOTTOM_RIGHT+]
+  #
+  # @example
+  #   text = "A label"
+  #   leader_type = Layout::Label::LEADER_LINE_TYPE_BEZIER
+  #   target_point = Geom::Point2d.new(1, 1)
+  #   bounds = Geom::Bounds2d.new(2, 1, 1, 1)
+  #   label_from_bounds = Layout::Label.new(text, leader_type, target_point,
+  #     bounds)
+  #   text_connection_type = label_from_bounds.connection_type
+  #
+  # @return [Integer]
+  #
+  # @version LayOut 2018
+  def connection_type
+  end
+
+  # The {#connection_type=} method sets the type of the text connection for the
+  # {Layout::Label}.
+  #
+  # The leader line type can be one of the following values:
+  # [+Layout::Label::CONNECTION_TYPE_NONE+]
+  # [+Layout::Label::CONNECTION_TYPE_AUTO+]
+  # [+Layout::Label::CONNECTION_TYPE_REVERSE_AUTO+]
+  # [+Layout::Label::CONNECTION_TYPE_TOP_LEFT+]
+  # [+Layout::Label::CONNECTION_TYPE_CENTER_LEFT+]
+  # [+Layout::Label::CONNECTION_TYPE_BOTTOM_LEFT+]
+  # [+Layout::Label::CONNECTION_TYPE_TOP_RIGHT+]
+  # [+Layout::Label::CONNECTION_TYPE_CENTER_RIGHT+]
+  # [+Layout::Label::CONNECTION_TYPE_BOTTOM_RIGHT+]
+  #
+  # @example
+  #   text = "A label"
+  #   leader_type = Layout::Label::LEADER_LINE_TYPE_BEZIER
+  #   target_point = Geom::Point2d.new(1, 1)
+  #   bounds = Geom::Bounds2d.new(2, 1, 1, 1)
+  #   label_from_bounds = Layout::Label.new(text, leader_type, target_point,
+  #     bounds)
+  #   label_from_bounds.connection_type = Layout::Label::CONNECTION_TYPE_TOP_LEFT
+  #
+  # @param [Integer] connection_type
+  #
+  # @raise [LockedLayerError] if the {Layout::Label} is on a locked
+  #   {Layout::Layer}
+  #
+  # @raise [ArgumentError] if the connection_type is not a valid text connection
+  #   type
+  #
+  # @raise [LockedEntityError] if the {Layout::Label} is locked
+  #
+  # @version LayOut 2018
+  def connection_type=(connection_type)
+  end
+
+  # The {#disconnect} method disconnects the {Layout::Label} from its
+  # {Layout::ConnectionPoint}. The leader line will not be adjusted by
+  # disconnecting from a {Layout::ConnectionPoint}.
+  #
+  # @example
+  #   doc = Layout::Document.open("C:/path/to/document.layout")
+  #   label = doc.pages.first.entities.first
+  #   label.disconnect
+  #
+  # @raise [LockedLayerError] if the {Layout::Label} is on a locked
+  #   {Layout::Layer}
+  #
+  # @raise [LockedEntityError] if the {Layout::Label} is locked
+  #
+  # @version LayOut 2018
+  def disconnect
+  end
+
+  # The {#entities} method returns the {Layout::Entities} that represent the
+  # {Layout::Label} in its exploded form.
+  #
+  # @example
+  #   text = "A label"
+  #   leader_type = Layout::Label::LEADER_LINE_TYPE_BEZIER
+  #   target_point = Geom::Point2d.new(1, 1)
+  #   bounds = Geom::Bounds2d.new(2, 1, 1, 1)
+  #   label_from_bounds = Layout::Label.new(text, leader_type, target_point,
+  #     bounds)
+  #   entities = label_from_bounds.entities
+  #
+  # @overload entities
+  #
+  #   @return [Layout::Entities]
+  #
+  # @overload entities(page)
+  #
+  #   @param [Layout::Page] page The {Layout::Page} to use to convert an
+  #     auto text tag to display text
+  #   @return [Layout::Entities]
+  #
+  # @raise [ArgumentError] if page does not belong to the same document as the
+  #   [Layout::Label]
+  #
+  # @version LayOut 2018
+  def entities(*args)
+  end
+
+  # The {#initialize} method creates a new disconnected {Layout::Label}.
+  #
+  # @example
+  #   text = "A label"
+  #   leader_type = Layout::Label::LEADER_LINE_TYPE_BEZIER
+  #   target_point = Geom::Point2d.new(1, 1)
+  #   bounds = Geom::Bounds2d.new(2, 1, 1, 1)
+  #   label_from_bounds = Layout::Label.new(text, leader_type, target_point,
+  #     bounds)
+  #   anchor_point = Geom::Point2d.new(2, 2)
+  #   anchor_type = Layout::FormattedText::ANCHOR_TYPE_TOP_RIGHT
+  #   label_from_point = Layout::Label.new(text, leader_type, target_point,
+  #     anchor_point, anchor_type)
+  #
+  # @overload initialize(text, leader_type, target_point, bounds)
+  #
+  #   @param [String] text The label text
+  #   @param [Integer] leader_type The leader line type
+  #   @param [Geom::Point2d] target_point Where the label leader should point to
+  #   @param [Geom::Bounds2d] bounds
+  #   @return [Layout::Label]
+  #
+  # @overload initialize(text, leader_type, target_point, anchor_point,
+  #
+  #   anchor_type)
+  #   @param [String] text The label text
+  #   @param [Integer] leader_type The leader line type
+  #   @param [Geom::Point2d] target_point Where the label leader should point to
+  #   @param [Geom::Point2d] anchor_point The anchor point for the label text's
+  #     position.
+  #   @param [Integer] anchor_type Defines which point of the label text is set
+  #     by anchor_point.
+  #   @return [Layout::Label]
+  #
+  # @raise [ArgumentError] if anchor_type is not a valid anchor type
+  #
+  # @raise [ArgumentError] if plain_text is an empty string
+  #
+  # @raise [ArgumentError] if bounds is zero size
+  #
+  # @raise [ArgumentError] if leader_type is not a valid leader line type
+  #
+  # @version LayOut 2018
+  def initialize(*args)
+  end
+
+  # The {#leader_line} method returns a copy of the leader line.
+  #
+  # @example
+  #   text = "A label"
+  #   leader_type = Layout::Label::LEADER_LINE_TYPE_BEZIER
+  #   target_point = Geom::Point2d.new(1, 1)
+  #   bounds = Geom::Bounds2d.new(2, 1, 1, 1)
+  #   label_from_bounds = Layout::Label.new(text, leader_type, target_point,
+  #     bounds)
+  #   leader = label_from_bounds.leader_line
+  #
+  # @return [Layout::Path]
+  #
+  # @version LayOut 2018
+  def leader_line
+  end
+
+  # The {#leader_line=} method sets the leader line.
+  #
+  # @example
+  #   text = "A label"
+  #   leader_type = Layout::Label::LEADER_LINE_TYPE_BEZIER
+  #   target_point = Geom::Point2d.new(1, 1)
+  #   bounds = Geom::Bounds2d.new(2, 1, 1, 1)
+  #   label_from_bounds = Layout::Label.new(text, leader_type, target_point,
+  #     bounds)
+  #   path = Layout::Path.new(Geom::Point2d.new(1, 2), Geom::Point2d.new(2, 3))
+  #   label_from_bounds.leader_line = path
+  #
+  # @param [Layout::Path] leader_path
+  #
+  # @raise [LockedEntityError] if the {Layout::Label} is locked
+  #
+  # @raise [LockedLayerError] if the {Layout::Label} is on a locked
+  #   {Layout::Layer}
+  #
+  # @version LayOut 2018
+  def leader_line=(leader_path)
+  end
+
+  # The {#leader_line_type} method returns the type of the leader line for the
+  # {Layout::Label}.
+  #
+  # The leader line type can be one of the following values:
+  # [+Layout::Label::LEADER_LINE_TYPE_SINGLE_SEGMENT+]
+  # [+Layout::Label::LEADER_LINE_TYPE_TWO_SEGMENT+]
+  # [+Layout::Label::LEADER_LINE_TYPE_BEZIER+]
+  # [+Layout::Label::LEADER_LINE_TYPE_UNKNOWN+]
+  #
+  # @example
+  #   text = "A label"
+  #   leader_type = Layout::Label::LEADER_LINE_TYPE_BEZIER
+  #   target_point = Geom::Point2d.new(1, 1)
+  #   bounds = Geom::Bounds2d.new(2, 1, 1, 1)
+  #   label_from_bounds = Layout::Label.new(text, leader_type, target_point,
+  #     bounds)
+  #   leader_type = label_from_bounds.leader_line_type
+  #
+  # @return [Integer]
+  #
+  # @version LayOut 2018
+  def leader_line_type
+  end
+
+  # The {#leader_line_type=} method sets the type of the leader line for the
+  # {Layout::Label}.
+  #
+  # The leader line type can be one of the following values:
+  # [+Layout::Label::LEADER_LINE_TYPE_SINGLE_SEGMENT+]
+  # [+Layout::Label::LEADER_LINE_TYPE_TWO_SEGMENT+]
+  # [+Layout::Label::LEADER_LINE_TYPE_BEZIER+]
+  # [+Layout::Label::LEADER_LINE_TYPE_UNKNOWN+]
+  #
+  # @example
+  #   text = "A label"
+  #   leader_type = Layout::Label::LEADER_LINE_TYPE_BEZIER
+  #   target_point = Geom::Point2d.new(1, 1)
+  #   bounds = Geom::Bounds2d.new(2, 1, 1, 1)
+  #   label_from_bounds = Layout::Label.new(text, leader_type, target_point,
+  #     bounds)
+  #   label_from_bounds.leader_line_type = Layout::Label::LEADER_LINE_TYPE_BEZIER
+  #
+  # @param [Integer] leader_type
+  #
+  # @raise [LockedLayerError] if the {Layout::Label} is on a locked
+  #   {Layout::Layer}
+  #
+  # @raise [ArgumentError] if leader_type is
+  #   +Layout::Label::LEADER_LINE_TYPE_UNKNOWN+ or not a valid leader line type
+  #
+  # @raise [LockedEntityError] if the {Layout::Label} is locked
+  #
+  # @version LayOut 2018
+  def leader_line_type=(leader_type)
+  end
+
+  # The {#text} method returns a copy of the {Layout::FormattedText} of the
+  # {Layout::Label}.
+  #
+  # @example
+  #   text = "A label"
+  #   leader_type = Layout::Label::LEADER_LINE_TYPE_BEZIER
+  #   target_point = Geom::Point2d.new(1, 1)
+  #   bounds = Geom::Bounds2d.new(2, 1, 1, 1)
+  #   label_from_bounds = Layout::Label.new(text, leader_type, target_point,
+  #     bounds)
+  #   text = label_from_bounds.text
+  #
+  # @return [Layout::FormattedText]
+  #
+  # @version LayOut 2018
+  def text
+  end
+
+  # The {#text=} method sets the {Layout::FormattedText} of the {Layout::Label}.
+  #
+  # @example
+  #   text = "A label"
+  #   leader_type = Layout::Label::LEADER_LINE_TYPE_BEZIER
+  #   target_point = Geom::Point2d.new(1, 1)
+  #   bounds = Geom::Bounds2d.new(2, 1, 1, 1)
+  #   label_from_bounds = Layout::Label.new(text, leader_type, target_point,
+  #     bounds)
+  #   anchor = Geom::Point2d.new(1, 1)
+  #   anchor_type = Layout::FormattedText::ANCHOR_TYPE_TOP_LEFT
+  #   text = Layout::FormattedText.new("Test", anchor, anchor_type)
+  #   label_from_bounds.text = text
+  #
+  # @param [Layout::FormattedText] new_text
+  #
+  # @raise [LockedEntityError] if the {Layout::Label} is locked
+  #
+  # @raise [LockedLayerError] if the {Layout::Label} is on a locked
+  #   {Layout::Layer}
+  #
+  # @version LayOut 2018
+  def text=(new_text)
+  end
+
+end