java.lang.Object
- io.cucumber.messages.types.Envelope

```
public class Envelope
extends Object
```
When removing a field, replace it with reserved, rather than deleting the line. When adding a field, add it to the end and increment the number by one. See https://developers.google.com/protocol-buffers/docs/proto#updating for details * All the messages that are passed between different components/processes are Envelope messages.

Constructor Summary

Constructors
Constructor	Description
`Envelope()`	No args constructor for use in serialization
`Envelope(Attachment attachment, GherkinDocument gherkinDocument, Hook hook, Meta meta, ParameterType parameterType, ParseError parseError, Pickle pickle, Source source, StepDefinition stepDefinition, TestCase testCase, TestCaseFinished testCaseFinished, TestCaseStarted testCaseStarted, TestRunFinished testRunFinished, TestRunStarted testRunStarted, TestStepFinished testStepFinished, TestStepStarted testStepStarted, UndefinedParameterType undefinedParameterType)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`boolean`	`equals(Object other)`
`Attachment`	`getAttachment()`	//// Attachments (parse errors, execution errors, screenshots, links...) * An attachment represents any kind of data associated with a line in a [Source](#io.cucumber.messages.Source) file.
`GherkinDocument`	`getGherkinDocument()`	* The [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree) of a Gherkin document.
`Hook`	`getHook()`
`Meta`	`getMeta()`	* This message contains meta information about the environment.
`ParameterType`	`getParameterType()`
`ParseError`	`getParseError()`
`Pickle`	`getPickle()`	//// Pickles * A `Pickle` represents a template for a `TestCase`.
`Source`	`getSource()`	//// Source * A source file, typically a Gherkin document or Java/Ruby/JavaScript source code
`StepDefinition`	`getStepDefinition()`
`TestCase`	`getTestCase()`	//// TestCases * A `TestCase` contains a sequence of `TestStep`s.
`TestCaseFinished`	`getTestCaseFinished()`
`TestCaseStarted`	`getTestCaseStarted()`
`TestRunFinished`	`getTestRunFinished()`
`TestRunStarted`	`getTestRunStarted()`
`TestStepFinished`	`getTestStepFinished()`
`TestStepStarted`	`getTestStepStarted()`
`UndefinedParameterType`	`getUndefinedParameterType()`
`int`	`hashCode()`
`void`	`setAttachment(Attachment attachment)`	//// Attachments (parse errors, execution errors, screenshots, links...) * An attachment represents any kind of data associated with a line in a [Source](#io.cucumber.messages.Source) file.
`void`	`setGherkinDocument(GherkinDocument gherkinDocument)`	* The [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree) of a Gherkin document.
`void`	`setHook(Hook hook)`
`void`	`setMeta(Meta meta)`	* This message contains meta information about the environment.
`void`	`setParameterType(ParameterType parameterType)`
`void`	`setParseError(ParseError parseError)`
`void`	`setPickle(Pickle pickle)`	//// Pickles * A `Pickle` represents a template for a `TestCase`.
`void`	`setSource(Source source)`	//// Source * A source file, typically a Gherkin document or Java/Ruby/JavaScript source code
`void`	`setStepDefinition(StepDefinition stepDefinition)`
`void`	`setTestCase(TestCase testCase)`	//// TestCases * A `TestCase` contains a sequence of `TestStep`s.
`void`	`setTestCaseFinished(TestCaseFinished testCaseFinished)`
`void`	`setTestCaseStarted(TestCaseStarted testCaseStarted)`
`void`	`setTestRunFinished(TestRunFinished testRunFinished)`
`void`	`setTestRunStarted(TestRunStarted testRunStarted)`
`void`	`setTestStepFinished(TestStepFinished testStepFinished)`
`void`	`setTestStepStarted(TestStepStarted testStepStarted)`
`void`	`setUndefinedParameterType(UndefinedParameterType undefinedParameterType)`
`String`	`toString()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - Envelope
```
public Envelope()
```
    No args constructor for use in serialization
  - Envelope
```
public Envelope(Attachment attachment,
                GherkinDocument gherkinDocument,
                Hook hook,
                Meta meta,
                ParameterType parameterType,
                ParseError parseError,
                Pickle pickle,
                Source source,
                StepDefinition stepDefinition,
                TestCase testCase,
                TestCaseFinished testCaseFinished,
                TestCaseStarted testCaseStarted,
                TestRunFinished testRunFinished,
                TestRunStarted testRunStarted,
                TestStepFinished testStepFinished,
                TestStepStarted testStepStarted,
                UndefinedParameterType undefinedParameterType)
```
    Parameters:
    
    parameterType -
    
    undefinedParameterType -
    
    parseError -
    
    source -
    
    pickle -
    
    testStepFinished -
    
    testCaseStarted -
    
    hook -
    
    attachment -
    
    testCaseFinished -
    
    meta -
    
    testRunStarted -
    
    gherkinDocument -
    
    stepDefinition -
    
    testCase -
    
    testRunFinished -
    
    testStepStarted -
- Method Detail
  - getAttachment
```
public Attachment getAttachment()
```
    //// Attachments (parse errors, execution errors, screenshots, links...) * An attachment represents any kind of data associated with a line in a [Source](#io.cucumber.messages.Source) file. It can be used for: * Syntax errors during parse time * Screenshots captured and attached during execution * Logs captured and attached during execution It is not to be used for runtime errors raised/thrown during execution. This is captured in `TestResult`.
  - setAttachment
```
public void setAttachment(Attachment attachment)
```
    //// Attachments (parse errors, execution errors, screenshots, links...) * An attachment represents any kind of data associated with a line in a [Source](#io.cucumber.messages.Source) file. It can be used for: * Syntax errors during parse time * Screenshots captured and attached during execution * Logs captured and attached during execution It is not to be used for runtime errors raised/thrown during execution. This is captured in `TestResult`.
  - getGherkinDocument
```
public GherkinDocument getGherkinDocument()
```
    * The [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree) of a Gherkin document. Cucumber implementations should *not* depend on `GherkinDocument` or any of its children for execution - use [Pickle](#io.cucumber.messages.Pickle) instead. The only consumers of `GherkinDocument` should only be formatters that produce "rich" output, resembling the original Gherkin document.
  - setGherkinDocument
```
public void setGherkinDocument(GherkinDocument gherkinDocument)
```
    * The [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree) of a Gherkin document. Cucumber implementations should *not* depend on `GherkinDocument` or any of its children for execution - use [Pickle](#io.cucumber.messages.Pickle) instead. The only consumers of `GherkinDocument` should only be formatters that produce "rich" output, resembling the original Gherkin document.
  - getHook
```
public Hook getHook()
```
  - setHook
```
public void setHook(Hook hook)
```
  - getMeta
```
public Meta getMeta()
```
    * This message contains meta information about the environment. Consumers can use this for various purposes.
  - setMeta
```
public void setMeta(Meta meta)
```
    * This message contains meta information about the environment. Consumers can use this for various purposes.
  - getParameterType
```
public ParameterType getParameterType()
```
  - setParameterType
```
public void setParameterType(ParameterType parameterType)
```
  - getParseError
```
public ParseError getParseError()
```
  - setParseError
```
public void setParseError(ParseError parseError)
```
  - getPickle
```
public Pickle getPickle()
```
    //// Pickles * A `Pickle` represents a template for a `TestCase`. It is typically derived from another format, such as [GherkinDocument](#io.cucumber.messages.GherkinDocument). In the future a `Pickle` may be derived from other formats such as Markdown or Excel files. By making `Pickle` the main data structure Cucumber uses for execution, the implementation of Cucumber itself becomes simpler, as it doesn't have to deal with the complex structure of a [GherkinDocument](#io.cucumber.messages.GherkinDocument). Each `PickleStep` of a `Pickle` is matched with a `StepDefinition` to create a `TestCase`
  - setPickle
```
public void setPickle(Pickle pickle)
```
    //// Pickles * A `Pickle` represents a template for a `TestCase`. It is typically derived from another format, such as [GherkinDocument](#io.cucumber.messages.GherkinDocument). In the future a `Pickle` may be derived from other formats such as Markdown or Excel files. By making `Pickle` the main data structure Cucumber uses for execution, the implementation of Cucumber itself becomes simpler, as it doesn't have to deal with the complex structure of a [GherkinDocument](#io.cucumber.messages.GherkinDocument). Each `PickleStep` of a `Pickle` is matched with a `StepDefinition` to create a `TestCase`
  - getSource
```
public Source getSource()
```
    //// Source * A source file, typically a Gherkin document or Java/Ruby/JavaScript source code
  - setSource
```
public void setSource(Source source)
```
    //// Source * A source file, typically a Gherkin document or Java/Ruby/JavaScript source code
  - getStepDefinition
```
public StepDefinition getStepDefinition()
```
  - setStepDefinition
```
public void setStepDefinition(StepDefinition stepDefinition)
```
  - getTestCase
```
public TestCase getTestCase()
```
    //// TestCases * A `TestCase` contains a sequence of `TestStep`s.
  - setTestCase
```
public void setTestCase(TestCase testCase)
```
    //// TestCases * A `TestCase` contains a sequence of `TestStep`s.
  - getTestCaseFinished
```
public TestCaseFinished getTestCaseFinished()
```
  - setTestCaseFinished
```
public void setTestCaseFinished(TestCaseFinished testCaseFinished)
```
  - getTestCaseStarted
```
public TestCaseStarted getTestCaseStarted()
```
  - setTestCaseStarted
```
public void setTestCaseStarted(TestCaseStarted testCaseStarted)
```
  - getTestRunFinished
```
public TestRunFinished getTestRunFinished()
```
  - setTestRunFinished
```
public void setTestRunFinished(TestRunFinished testRunFinished)
```
  - getTestRunStarted
```
public TestRunStarted getTestRunStarted()
```
  - setTestRunStarted
```
public void setTestRunStarted(TestRunStarted testRunStarted)
```
  - getTestStepFinished
```
public TestStepFinished getTestStepFinished()
```
  - setTestStepFinished
```
public void setTestStepFinished(TestStepFinished testStepFinished)
```
  - getTestStepStarted
```
public TestStepStarted getTestStepStarted()
```
  - setTestStepStarted
```
public void setTestStepStarted(TestStepStarted testStepStarted)
```
  - getUndefinedParameterType
```
public UndefinedParameterType getUndefinedParameterType()
```
  - setUndefinedParameterType
```
public void setUndefinedParameterType(UndefinedParameterType undefinedParameterType)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object other)
```
    Overrides:
    
    equals in class Object

Class Envelope

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Envelope

Envelope

Method Detail

getAttachment

setAttachment

getGherkinDocument

setGherkinDocument

getHook

setHook

getMeta

setMeta

getParameterType

setParameterType

getParseError

setParseError

getPickle

setPickle

getSource

setSource

getStepDefinition

setStepDefinition

getTestCase

setTestCase

getTestCaseFinished

setTestCaseFinished

getTestCaseStarted

setTestCaseStarted

getTestRunFinished

setTestRunFinished

getTestRunStarted

setTestRunStarted

getTestStepFinished

setTestStepFinished

getTestStepStarted

setTestStepStarted

getUndefinedParameterType

setUndefinedParameterType

toString

hashCode

equals