type Puppet::AST = TypeSet[{
  pcore_version => '1.0.0',
  types => {
    Locator => Object[{
      attributes => {
        'string' => String,
        'file' => String,
        'line_index' => {
          type => Optional[Array[Integer]],
          value => undef
        }
      }
    }],
    PopsObject => Object[{
    }],
    Positioned => Object[{
      parent => PopsObject,
      attributes => {
        'locator' => {
          type => Locator,
          kind => reference
        },
        'offset' => Integer,
        'length' => Integer,
        'file' => {
          type => String,
          kind => derived,
          annotations => {
             RubyMethod => { 'body' => '@locator.file' }
          }
        },
        'line' => {
          type => Integer,
          kind => derived,
          annotations => {
            RubyMethod => { 'body' => '@locator.line_for_offset(@offset)' }
          }
        },
        'pos' => {
          type => Integer,
          kind => derived,
          annotations => {
            RubyMethod => { 'body' => '@locator.pos_on_line(@offset)' }
          }
        }
      },
      equality => []
    }],
    Expression => Object[{
      parent => Positioned
    }],
    Nop => Object[{
      parent => Expression
    }],
    BinaryExpression => Object[{
      parent => Expression,
      attributes => {
        'left_expr' => Expression,
        'right_expr' => Expression
      }
    }],
    UnaryExpression => Object[{
      parent => Expression,
      attributes => {
        'expr' => Expression
      }
    }],
    ParenthesizedExpression => Object[{
      parent => UnaryExpression
    }],
    NotExpression => Object[{
      parent => UnaryExpression
    }],
    UnaryMinusExpression => Object[{
      parent => UnaryExpression
    }],
    UnfoldExpression => Object[{
      parent => UnaryExpression
    }],
    AssignmentExpression => Object[{
      parent => BinaryExpression,
      attributes => {
        'operator' => Enum['+=', '-=', '=']
      }
    }],
    ArithmeticExpression => Object[{
      parent => BinaryExpression,
      attributes => {
        'operator' => Enum['%', '*', '+', '-', '/', '<<', '>>']
      }
    }],
    RelationshipExpression => Object[{
      parent => BinaryExpression,
      attributes => {
        'operator' => Enum['->', '<-', '<~', '~>']
      }
    }],
    AccessExpression => Object[{
      parent => Expression,
      attributes => {
        'left_expr' => Expression,
        'keys' => {
          type => Array[Expression],
          value => []
        }
      }
    }],
    ComparisonExpression => Object[{
      parent => BinaryExpression,
      attributes => {
        'operator' => Enum['!=', '<', '<=', '==', '>', '>=']
      }
    }],
    MatchExpression => Object[{
      parent => BinaryExpression,
      attributes => {
        'operator' => Enum['!~', '=~']
      }
    }],
    InExpression => Object[{
      parent => BinaryExpression
    }],
    BooleanExpression => Object[{
      parent => BinaryExpression
    }],
    AndExpression => Object[{
      parent => BooleanExpression
    }],
    OrExpression => Object[{
      parent => BooleanExpression
    }],
    LiteralList => Object[{
      parent => Expression,
      attributes => {
        'values' => {
          type => Array[Expression],
          value => []
        }
      }
    }],
    KeyedEntry => Object[{
      parent => Positioned,
      attributes => {
        'key' => Expression,
        'value' => Expression
      }
    }],
    LiteralHash => Object[{
      parent => Expression,
      attributes => {
        'entries' => {
          type => Array[KeyedEntry],
          value => []
        }
      }
    }],
    BlockExpression => Object[{
      parent => Expression,
      attributes => {
        'statements' => {
          type => Array[Expression],
          value => []
        }
      }
    }],
    ApplyBlockExpression => Object[{
      parent => BlockExpression,
    }],
    CaseOption => Object[{
      parent => Expression,
      attributes => {
        'values' => Array[Expression, 1, default],
        'then_expr' => {
          type => Optional[Expression],
          value => undef
        }
      }
    }],
    CaseExpression => Object[{
      parent => Expression,
      attributes => {
        'test' => Expression,
        'options' => {
          type => Array[CaseOption],
          value => []
        }
      }
    }],
    QueryExpression => Object[{
      parent => Expression,
      attributes => {
        'expr' => {
          type => Optional[Expression],
          value => undef
        }
      }
    }],
    ExportedQuery => Object[{
      parent => QueryExpression
    }],
    VirtualQuery => Object[{
      parent => QueryExpression
    }],
    AbstractAttributeOperation => Object[{
      parent => Positioned
    }],
    AttributeOperation => Object[{
      parent => AbstractAttributeOperation,
      attributes => {
        'attribute_name' => String,
        'operator' => Enum['+>', '=>'],
        'value_expr' => Expression
      }
    }],
    AttributesOperation => Object[{
      parent => AbstractAttributeOperation,
      attributes => {
        'expr' => Expression
      }
    }],
    CollectExpression => Object[{
      parent => Expression,
      attributes => {
        'type_expr' => Expression,
        'query' => QueryExpression,
        'operations' => {
          type => Array[AbstractAttributeOperation],
          value => []
        }
      }
    }],
    Parameter => Object[{
      parent => Positioned,
      attributes => {
        'name' => String,
        'value' => {
          type => Optional[Expression],
          value => undef
        },
        'type_expr' => {
          type => Optional[Expression],
          value => undef
        },
        'captures_rest' => {
          type => Optional[Boolean],
          value => undef
        }
      }
    }],
    Definition => Object[{
      parent => Expression
    }],
    NamedDefinition => Object[{
      parent => Definition,
      attributes => {
        'name' => String,
        'parameters' => {
          type => Array[Parameter],
          value => []
        },
        'body' => {
          type => Optional[Expression],
          value => undef
        }
      }
    }],
    FunctionDefinition => Object[{
      parent => NamedDefinition,
      attributes => {
        'return_type' => {
          type => Optional[Expression],
          value => undef
        }
      }
    }],
    ResourceTypeDefinition => Object[{
      parent => NamedDefinition
    }],
    QRefDefinition => Object[{
      parent => Definition,
      attributes => {
        'name' => String
      }
    }],
    TypeAlias => Object[{
      parent => QRefDefinition,
      attributes => {
        'type_expr' => {
          type => Optional[Expression],
          value => undef
        }
      }
    }],
    TypeMapping => Object[{
      parent => Definition,
      attributes => {
        'type_expr' => {
          type => Optional[Expression],
          value => undef
        },
        'mapping_expr' => {
          type => Optional[Expression],
          value => undef
        }
      }
    }],
    TypeDefinition => Object[{
      parent => QRefDefinition,
      attributes => {
        'parent' => {
          type => Optional[String],
          value => undef
        },
        'body' => {
          type => Optional[Expression],
          value => undef
        }
      }
    }],
    NodeDefinition => Object[{
      parent => Definition,
      attributes => {
        'parent' => {
          type => Optional[Expression],
          value => undef
        },
        'host_matches' => Array[Expression, 1, default],
        'body' => {
          type => Optional[Expression],
          value => undef
        }
      }
    }],
    HeredocExpression => Object[{
      parent => Expression,
      attributes => {
        'syntax' => {
          type => Optional[String],
          value => undef
        },
        'text_expr' => Expression
      }
    }],
    HostClassDefinition => Object[{
      parent => NamedDefinition,
      attributes => {
        'parent_class' => {
          type => Optional[String],
          value => undef
        }
      }
    }],
    PlanDefinition => Object[{
      parent => FunctionDefinition,
    }],
    LambdaExpression => Object[{
      parent => Expression,
      attributes => {
        'parameters' => {
          type => Array[Parameter],
          value => []
        },
        'body' => {
          type => Optional[Expression],
          value => undef
        },
        'return_type' => {
          type => Optional[Expression],
          value => undef
        }
      }
    }],
    ApplyExpression => Object[{
      parent => Expression,
      attributes => {
        'arguments' => {
          type => Array[Expression],
          value => []
        },
        'body' => {
          type => Optional[Expression],
          value => undef
        }
      }
    }],
    IfExpression => Object[{
      parent => Expression,
      attributes => {
        'test' => Expression,
        'then_expr' => {
          type => Optional[Expression],
          value => undef
        },
        'else_expr' => {
          type => Optional[Expression],
          value => undef
        }
      }
    }],
    UnlessExpression => Object[{
      parent => IfExpression
    }],
    CallExpression => Object[{
      parent => Expression,
      attributes => {
        'rval_required' => {
          type => Boolean,
          value => false
        },
        'functor_expr' => Expression,
        'arguments' => {
          type => Array[Expression],
          value => []
        },
        'lambda' => {
          type => Optional[Expression],
          value => undef
        }
      }
    }],
    CallFunctionExpression => Object[{
      parent => CallExpression
    }],
    CallNamedFunctionExpression => Object[{
      parent => CallExpression
    }],
    CallMethodExpression => Object[{
      parent => CallExpression
    }],
    Literal => Object[{
      parent => Expression
    }],
    LiteralValue => Object[{
      parent => Literal
    }],
    LiteralRegularExpression => Object[{
      parent => LiteralValue,
      attributes => {
        'value' => Any,
        'pattern' => String
      }
    }],
    LiteralString => Object[{
      parent => LiteralValue,
      attributes => {
        'value' => String
      }
    }],
    LiteralNumber => Object[{
      parent => LiteralValue
    }],
    LiteralInteger => Object[{
      parent => LiteralNumber,
      attributes => {
        'radix' => {
          type => Integer,
          value => 10
        },
        'value' => Integer
      }
    }],
    LiteralFloat => Object[{
      parent => LiteralNumber,
      attributes => {
        'value' => Float
      }
    }],
    LiteralUndef => Object[{
      parent => Literal
    }],
    LiteralDefault => Object[{
      parent => Literal
    }],
    LiteralBoolean => Object[{
      parent => LiteralValue,
      attributes => {
        'value' => Boolean
      }
    }],
    TextExpression => Object[{
      parent => UnaryExpression
    }],
    ConcatenatedString => Object[{
      parent => Expression,
      attributes => {
        'segments' => {
          type => Array[Expression],
          value => []
        }
      }
    }],
    QualifiedName => Object[{
      parent => LiteralValue,
      attributes => {
        'value' => String
      }
    }],
    ReservedWord => Object[{
      parent => LiteralValue,
      attributes => {
        'word' => String,
        'future' => {
          type => Optional[Boolean],
          value => undef
        }
      }
    }],
    QualifiedReference => Object[{
      parent => LiteralValue,
      attributes => {
        'cased_value' => String,
        'value' => {
          type => String,
          kind => derived,
          annotations => {
            RubyMethod => { 'body' => '@cased_value.downcase' }
          }
        }
      }
    }],
    VariableExpression => Object[{
      parent => UnaryExpression
    }],
    EppExpression => Object[{
      parent => Expression,
      attributes => {
        'parameters_specified' => {
          type => Optional[Boolean],
          value => undef
        },
        'body' => {
          type => Optional[Expression],
          value => undef
        }
      }
    }],
    RenderStringExpression => Object[{
      parent => LiteralString
    }],
    RenderExpression => Object[{
      parent => UnaryExpression
    }],
    ResourceBody => Object[{
      parent => Positioned,
      attributes => {
        'title' => {
          type => Optional[Expression],
          value => undef
        },
        'operations' => {
          type => Array[AbstractAttributeOperation],
          value => []
        }
      }
    }],
    AbstractResource => Object[{
      parent => Expression,
      attributes => {
        'form' => {
          type => Enum['exported', 'regular', 'virtual'],
          value => 'regular'
        },
        'virtual' => {
          type => Boolean,
          kind => derived,
          annotations => {
            RubyMethod => { 'body' => "@form == 'virtual' || @form == 'exported'" }
          }
        },
        'exported' => {
          type => Boolean,
          kind => derived,
          annotations => {
            RubyMethod => { 'body' => "@form == 'exported'" }
          }
        }
      }
    }],
    ResourceExpression => Object[{
      parent => AbstractResource,
      attributes => {
        'type_name' => Expression,
        'bodies' => {
          type => Array[ResourceBody],
          value => []
        }
      }
    }],
    ResourceDefaultsExpression => Object[{
      parent => AbstractResource,
      attributes => {
        'type_ref' => {
          type => Optional[Expression],
          value => undef
        },
        'operations' => {
          type => Array[AbstractAttributeOperation],
          value => []
        }
      }
    }],
    ResourceOverrideExpression => Object[{
      parent => AbstractResource,
      attributes => {
        'resources' => Expression,
        'operations' => {
          type => Array[AbstractAttributeOperation],
          value => []
        }
      }
    }],
    SelectorEntry => Object[{
      parent => Positioned,
      attributes => {
        'matching_expr' => Expression,
        'value_expr' => Expression
      }
    }],
    SelectorExpression => Object[{
      parent => Expression,
      attributes => {
        'left_expr' => Expression,
        'selectors' => {
          type => Array[SelectorEntry],
          value => []
        }
      }
    }],
    NamedAccessExpression => Object[{
      parent => BinaryExpression
    }],
    Program => Object[{
      parent => PopsObject,
      attributes => {
        'body' => {
          type => Optional[Expression],
          value => undef
        },
        'definitions' => {
          type => Array[Definition],
          kind => reference,
          value => []
        },
        'source_text' => {
          type => String,
          kind => derived,
          annotations => {
            RubyMethod => { 'body' => '@locator.string' }
          }
        },
        'source_ref' => {
          type => String,
          kind => derived,
          annotations => {
            RubyMethod => { 'body' => '@locator.file' }
          }
        },
        'line_offsets' => {
          type => Array[Integer],
          kind => derived,
          annotations => {
            RubyMethod => { 'body' => '@locator.line_index' }
          }
        },
        'locator' => Locator
      }
    }]
  }
}]