4.2 Packages
A package provides a way to organize component types, component implementations, port group types, and annex libraries into related sets of declarations by introducing separate namespaces. Package names built using identifiers separated by double colons (“::”). This avoids the problem of duplicate names which might occur when packages are developed independently and then combined to model an integrated system.  In other words, complete_sys::first_independent::fuel_flow is distinct from complete_sys::second_independent::fuel_flow.  Packages cannot be declared inside other packages.
Syntax
package_spec ::=
    package defining_package_name
     ( public package_declaration [ private package_declaration ]
       | private package_declaration )
    end defining_package_name ;

package_declaration ::= { aadl_declaration }+
                        [ properties ( { property_association } |           
                                         none_statement ) ]

package_name ::=
    { package_identifier :: }* package_identifier

none_statement ::= none ;

NOTES:
The properties subclause of the package is optional, or requires an explicit empty subclause declaration.  The latter is provided to accommodate AADL modeling guidelines that require explicit documentation of empty subclauses. An empty subclause declaration consists of the reserved word of the subclause and a none statement     ( none ; ).
Naming Rules
A defining package name consists of a sequence of one or more package identifiers separated by a double colon (“::”).  A defining package name must be unique in the global namespace.  This means that the first identifier in a package name must be unique in the global namespace. Succeeding identifiers in the package name must be unique within the scope of the previous identifier.  The public and private section of a package may be declared in separate package declarations; these two declarations introduce a single defining package name.
Associated with every package is a package namespace that contains the names for all the elements defined within that package.  This means that component types, port group types, and defining entities declared in an annex library using an annex-specific sublanguage can be declared with the same name in different packages. 
The package namespace is divided into a public part and a private part.  Items declared in the public part of the package namespace can be referenced from outside the package as well as within the package.  Items declared in the private part of the package can only be referenced from within the public and private part of the package. 
The reference to an item declared in another package must be an item name qualified with a package name separated by a double colon (“::”).  Only the public package namespace is used to resolve these references.  If the qualifying package identifier is missing, the referenced component classifier, port group type, or item in an annex library must exist in the same package, or in case of references from declarations in the AADL specification itself the referenced item must exist in the anonymous namespace. Component types, component implementations, port group types, and items in annex libraries declared directly in the AADL specification, i.e., the anonymous namespace, can only be referenced by other declarations in the AADL specification itself.
Legality Rules
The defining package name following the reserved word end must be identical to the defining package name following the reserved word package.
For each package there may be at most one public section declaration and one private section declaration.  These two sections may be declared in a single package declaration or in two separate package declarations.
Semantics
A package provides a way to organize component type declarations, component implementation declarations, port group types, and annex libraries into related sets of declarations along with relevant property associations.  It provides a namespace for component types, port group types, and annex libraries with the package name acting as a qualifier.  Nested package names allow for unique package naming conventions that address potential name conflicts in component type and implementation names when independently developed AADL specifications are combined.  Note that component implementations are named relative to component types. Thus, qualified component type names act as unique qualifier for component implemenation names.  Packages can be organized hierarchically by giving them nested package names.  These package names represent absolute paths from the root of the package hierarchy.
Packages have a public and a private section.  Declarations in the public section are visible outside the package, i.e., names declared in the public part can be referenced by declarations in other AADL specifications. Declarations in the private part are visible only within the package, i.e., names declared in the private part can only be referenced by declarations within the package.