As written above the header is only present in v2 and v3 files. It consists of a first part that is present in both versions and a second part that's only present in v3 files.

typedef struct {
	uint8 nullbytes[8];     // Always 0x00
	uint8 formatbyte;       // 0x1F for v2 and 0x2F for v3
	uint8 alwaysDA;         // Always 0xDA
	uint8 always1E;         // Always 0x1E
	uint8 alwaysF1;         // Always 0xF1
	uint32 parameters[13];  // Unknown purpose. Some seem to relate to the file coming from Soaked! or Wild!
} Header1;

typedef struct {
	uint32 unknown;      // 0x00000000 for park-ish files (parks, most scenarios and tutorials), 0xFFFFFFFF for other files
	uint32 ffbytes;      // Always 0xFFFFFFFF
	uint8 nullbytes[8];  // Always 0x00
} Header2;

This section describes the classes and structures the data part (Section 3, “The Data”) can use. Version 1 and 2 files seem to declare almost everything RCT3 can use (although the amount is not consistant). On the other hand v3 files seem to only declare what's necessary for the file type at hand.

All strings in this section are AscII long pascal style strings, essentially described by this declaration:

typedef struct {
	uint16 charactercount;
	char content[charactercount];
} DeclarationString;

To emphasize, they are not 0-terminated!

Here is how this section looks like:

uint32 classdeclarationcount;
ClassDeclaration classdec[classdeclarationcount];

Here's how a ClassDeclaration looks like:

typedef struct {
	DeclarationString classname;
	uint32 variablecount;
	VariableDeclaration variable[variablecount];
} ClassDeclaration;

And finally VariableDeclaration:

typedef struct {
	DeclarationString variablename;
	DeclarationString datatypename;
	uint32 datatypesize;       // Size of the data type in bytes
	uint32 subvariablecount;   // Number of subvariables for some data types
	VariableDeclaration subvariable[subvariablecount];
} VariableDeclaration;

The datatypesize parameter is a numerical representation of the data type named in datatypename. A 0 seems to indicate a data type of variable size. Here is a list of data types I found so far:

The data section seems to be nearly identical among versions. It is separated in to class blocks and starts with the number of these blocks:

uint32 classdatablockcount;

Followed by the class data blocks themselves. Each class block starts with a header:

typedef struct {
	uint32 classid;     // Identifies which class declaration applies (classdec[classid])
	char refmarker[8];  // Used for in-file references.
} ClassDataHeader;

The header is followed by the actual data as described in the class' declaration.

All data is represented as a raw little endian data type of the respective length with the following exceptions (incomplete):

typedef struct {
	uint32 arraylength;         // in bytes. Includes the 4 bytes of the itemcount
	uint32 itemcount;           // number of items in the array
	ArrayItem item[itemcount];  // ArrayItem as defined in the declaration section
} ArrayData;

typedef struct {
	char reference[8];  // references a class data block by it's ClassDataHeader.refmarker
} ReferenceData;

typedef struct {
	uint32 stringlength;                // in bytes. Start marker is included.
	uint8 startmarker[4];               // All 0xEF
	wchar content[(stringlength-4)/2];  // UTF16, little endian
} StringData;

typedef struct {
	uint32 structlength;          // in bytes. Full size of the content
	uint8 content[structlength];  // Data as defined as subvariables in the declaration section
} StructData;

After the data, there is a last value in v2 and v3 files:

uint32 unknownend;

The exact purpose is unknown purpose, maybe some kind of checksum. It is too big to indicate a size inside the file.