text: //
  // Copyright 2016 Pixar
  //
  // Licensed under the Apache License, Version 2.0 (the "Apache License")
  // with the following modification; you may not use this file except in
  // compliance with the Apache License and the following modification to it:
  // Section 6. Trademarks. is deleted and replaced with:
  //
  // 6. Trademarks. This License does not grant permission to use the trade
  //    names, trademarks, service marks, or product names of the Licensor
  //    and its affiliates, except as required to comply with Section 4(c) of
  //    the License and to reproduce the content of the NOTICE file.
  //
  // You may obtain a copy of the Apache License at
  //
  //     http://www.apache.org/licenses/LICENSE-2.0
  //
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the Apache License with the above modification is
  // distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  // KIND, either express or implied. See the Apache License for the specific
  // language governing permissions and limitations under the Apache License.
  //
  #ifndef USDCONTRIVED_GENERATED_BASE_H
  #define USDCONTRIVED_GENERATED_BASE_H
  
  /// \file usdContrived/base.h
  
  #include "pxr/pxr.h"
  #include "pxr/usd/usdContrived/api.h"
  #include "pxr/usd/usd/typed.h"
  #include "pxr/usd/usd/prim.h"
  #include "pxr/usd/usd/stage.h"
  #include "pxr/usd/usdContrived/tokens.h"
  
  #include "pxr/base/vt/value.h"
  
  #include "pxr/base/gf/vec3d.h"
  #include "pxr/base/gf/vec3f.h"
  #include "pxr/base/gf/matrix4d.h"
  
  #include "pxr/base/tf/token.h"
  #include "pxr/base/tf/type.h"
  
  namespace foo {
  
  class SdfAssetPath;
  
  // -------------------------------------------------------------------------- //
  // BASE                                                                       //
  // -------------------------------------------------------------------------- //
  
  /// \class UsdContrivedBase
  ///
  /// This doc should only exist on the "Base" class.
  ///
  /// For any described attribute \em Fallback \em Value or \em Allowed \em Values below
  /// that are text/tokens, the actual token is published and defined in \ref UsdContrivedTokens.
  /// So to set an attribute to the value "rightHanded", use UsdContrivedTokens->rightHanded
  /// as the value.
  ///
  class UsdContrivedBase : public UsdTyped
  {
  public:
      /// Compile time constant representing what kind of schema this class is.
      ///
      /// \sa UsdSchemaKind
      static const UsdSchemaKind schemaKind = UsdSchemaKind::AbstractTyped;
  
      /// \deprecated
      /// Same as schemaKind, provided to maintain temporary backward 
      /// compatibility with older generated schemas.
      static const UsdSchemaKind schemaType = UsdSchemaKind::AbstractTyped;
  
      /// Construct a UsdContrivedBase on UsdPrim \p prim .
      /// Equivalent to UsdContrivedBase::Get(prim.GetStage(), prim.GetPath())
      /// for a \em valid \p prim, but will not immediately throw an error for
      /// an invalid \p prim
      explicit UsdContrivedBase(const UsdPrim& prim=UsdPrim())
          : UsdTyped(prim)
      {
      }
  
      /// Construct a UsdContrivedBase on the prim held by \p schemaObj .
      /// Should be preferred over UsdContrivedBase(schemaObj.GetPrim()),
      /// as it preserves SchemaBase state.
      explicit UsdContrivedBase(const UsdSchemaBase& schemaObj)
          : UsdTyped(schemaObj)
      {
      }
  
      /// Destructor.
      USDCONTRIVED_API
      virtual ~UsdContrivedBase();
  
      /// Return a vector of names of all pre-declared attributes for this schema
      /// class and all its ancestor classes.  Does not include attributes that
      /// may be authored by custom/extended methods of the schemas involved.
      USDCONTRIVED_API
      static const TfTokenVector &
      GetSchemaAttributeNames(bool includeInherited=true);
  
      /// Return a UsdContrivedBase holding the prim adhering to this
      /// schema at \p path on \p stage.  If no prim exists at \p path on
      /// \p stage, or if the prim at that path does not adhere to this schema,
      /// return an invalid schema object.  This is shorthand for the following:
      ///
      /// \code
      /// UsdContrivedBase(stage->GetPrimAtPath(path));
      /// \endcode
      ///
      USDCONTRIVED_API
      static UsdContrivedBase
      Get(const UsdStagePtr &stage, const SdfPath &path);
  
  
  protected:
      /// Returns the kind of schema this class belongs to.
      ///
      /// \sa UsdSchemaKind
      USDCONTRIVED_API
      UsdSchemaKind _GetSchemaKind() const override;
  
      /// \deprecated
      /// Same as _GetSchemaKind, provided to maintain temporary backward 
      /// compatibility with older generated schemas.
      USDCONTRIVED_API
      UsdSchemaKind _GetSchemaType() const override;
  
  private:
      // needs to invoke _GetStaticTfType.
      friend class UsdSchemaRegistry;
      USDCONTRIVED_API
      static const TfType &_GetStaticTfType();
  
      static bool _IsTypedSchema();
  
      // override SchemaBase virtuals.
      USDCONTRIVED_API
      const TfType &_GetTfType() const override;
  
  public:
      // --------------------------------------------------------------------- //
      // MYVARYINGTOKEN 
      // --------------------------------------------------------------------- //
      /// VariableToken attribute docs.
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `token myVaryingToken = "VariableTokenDefault"` |
      /// | C++ Type | TfToken |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Token |
      /// | \ref UsdContrivedTokens "Allowed Values" | VariableTokenAllowed1, VariableTokenAllowed2, "" |
      USDCONTRIVED_API
      UsdAttribute GetMyVaryingTokenAttr() const;
  
      /// See GetMyVaryingTokenAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateMyVaryingTokenAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // MYVARYINGTOKENARRAY 
      // --------------------------------------------------------------------- //
      /// VariableTokenArray attribute docs.
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `uniform token[] myVaryingTokenArray = ["VariableTokenArrayAllowed1", ""]` |
      /// | C++ Type | VtArray<TfToken> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->TokenArray |
      /// | \ref SdfVariability "Variability" | SdfVariabilityUniform |
      /// | \ref UsdContrivedTokens "Allowed Values" | VariableTokenArrayAllowed1, VariableTokenArrayAllowed2, "" |
      USDCONTRIVED_API
      UsdAttribute GetMyVaryingTokenArrayAttr() const;
  
      /// See GetMyVaryingTokenArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateMyVaryingTokenArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // MYUNIFORMBOOL 
      // --------------------------------------------------------------------- //
      /// Uniform bool, default false
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `uniform bool myUniformBool = 0` |
      /// | C++ Type | bool |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool |
      /// | \ref SdfVariability "Variability" | SdfVariabilityUniform |
      USDCONTRIVED_API
      UsdAttribute GetMyUniformBoolAttr() const;
  
      /// See GetMyUniformBoolAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateMyUniformBoolAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // MYDOUBLE 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `double myDouble` |
      /// | C++ Type | double |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double |
      USDCONTRIVED_API
      UsdAttribute GetMyDoubleAttr() const;
  
      /// See GetMyDoubleAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateMyDoubleAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // BOOL 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `bool bool = 1` |
      /// | C++ Type | bool |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Bool |
      USDCONTRIVED_API
      UsdAttribute GetBoolAttr() const;
  
      /// See GetBoolAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateBoolAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // UCHAR 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `uchar uchar = 0` |
      /// | C++ Type | unsigned char |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->UChar |
      USDCONTRIVED_API
      UsdAttribute GetUcharAttr() const;
  
      /// See GetUcharAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateUcharAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // INT 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `int int = 0` |
      /// | C++ Type | int |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int |
      USDCONTRIVED_API
      UsdAttribute GetIntAttr() const;
  
      /// See GetIntAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateIntAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // UINT 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `uint uint = 0` |
      /// | C++ Type | unsigned int |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->UInt |
      USDCONTRIVED_API
      UsdAttribute GetUintAttr() const;
  
      /// See GetUintAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateUintAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // INT64 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `int64 int64 = 0` |
      /// | C++ Type | int64_t |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int64 |
      USDCONTRIVED_API
      UsdAttribute GetInt64Attr() const;
  
      /// See GetInt64Attr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateInt64Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // UINT64 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `uint64 uint64 = 0` |
      /// | C++ Type | uint64_t |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->UInt64 |
      USDCONTRIVED_API
      UsdAttribute GetUint64Attr() const;
  
      /// See GetUint64Attr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateUint64Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // HALF 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `half half = 0` |
      /// | C++ Type | GfHalf |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Half |
      USDCONTRIVED_API
      UsdAttribute GetHalfAttr() const;
  
      /// See GetHalfAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateHalfAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // FLOAT 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `float float = 0` |
      /// | C++ Type | float |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Float |
      USDCONTRIVED_API
      UsdAttribute GetFloatAttr() const;
  
      /// See GetFloatAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateFloatAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // DOUBLE 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `double double = 0` |
      /// | C++ Type | double |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double |
      USDCONTRIVED_API
      UsdAttribute GetDoubleAttr() const;
  
      /// See GetDoubleAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateDoubleAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // STRING 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `string string = "string"` |
      /// | C++ Type | std::string |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->String |
      USDCONTRIVED_API
      UsdAttribute GetStringAttr() const;
  
      /// See GetStringAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateStringAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // TOKEN 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `token token = "token"` |
      /// | C++ Type | TfToken |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Token |
      USDCONTRIVED_API
      UsdAttribute GetTokenAttr() const;
  
      /// See GetTokenAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateTokenAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // ASSET 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `asset asset = @asset@` |
      /// | C++ Type | SdfAssetPath |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Asset |
      USDCONTRIVED_API
      UsdAttribute GetAssetAttr() const;
  
      /// See GetAssetAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateAssetAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // INT2 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `int2 int2 = (0, 0)` |
      /// | C++ Type | GfVec2i |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int2 |
      USDCONTRIVED_API
      UsdAttribute GetInt2Attr() const;
  
      /// See GetInt2Attr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateInt2Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // INT3 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `int3 int3 = (0, 0, 0)` |
      /// | C++ Type | GfVec3i |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int3 |
      USDCONTRIVED_API
      UsdAttribute GetInt3Attr() const;
  
      /// See GetInt3Attr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateInt3Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // INT4 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `int4 int4 = (0, 0, 0, 0)` |
      /// | C++ Type | GfVec4i |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int4 |
      USDCONTRIVED_API
      UsdAttribute GetInt4Attr() const;
  
      /// See GetInt4Attr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateInt4Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // HALF2 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `half2 half2 = (0, 0)` |
      /// | C++ Type | GfVec2h |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Half2 |
      USDCONTRIVED_API
      UsdAttribute GetHalf2Attr() const;
  
      /// See GetHalf2Attr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateHalf2Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // HALF3 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `half3 half3 = (0, 0, 0)` |
      /// | C++ Type | GfVec3h |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Half3 |
      USDCONTRIVED_API
      UsdAttribute GetHalf3Attr() const;
  
      /// See GetHalf3Attr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateHalf3Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // HALF4 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `half4 half4 = (0, 0, 0, 0)` |
      /// | C++ Type | GfVec4h |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Half4 |
      USDCONTRIVED_API
      UsdAttribute GetHalf4Attr() const;
  
      /// See GetHalf4Attr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateHalf4Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // FLOAT2 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `float2 float2 = (0, 0)` |
      /// | C++ Type | GfVec2f |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Float2 |
      USDCONTRIVED_API
      UsdAttribute GetFloat2Attr() const;
  
      /// See GetFloat2Attr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateFloat2Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // FLOAT3 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `float3 float3 = (0, 0, 0)` |
      /// | C++ Type | GfVec3f |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Float3 |
      USDCONTRIVED_API
      UsdAttribute GetFloat3Attr() const;
  
      /// See GetFloat3Attr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateFloat3Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // FLOAT4 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `float4 float4 = (0, 0, 0, 0)` |
      /// | C++ Type | GfVec4f |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Float4 |
      USDCONTRIVED_API
      UsdAttribute GetFloat4Attr() const;
  
      /// See GetFloat4Attr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateFloat4Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // DOUBLE2 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `double2 double2 = (0, 0)` |
      /// | C++ Type | GfVec2d |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double2 |
      USDCONTRIVED_API
      UsdAttribute GetDouble2Attr() const;
  
      /// See GetDouble2Attr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateDouble2Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // DOUBLE3 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `double3 double3 = (0, 0, 0)` |
      /// | C++ Type | GfVec3d |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double3 |
      USDCONTRIVED_API
      UsdAttribute GetDouble3Attr() const;
  
      /// See GetDouble3Attr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateDouble3Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // DOUBLE4 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `double4 double4 = (0, 0, 0, 0)` |
      /// | C++ Type | GfVec4d |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double4 |
      USDCONTRIVED_API
      UsdAttribute GetDouble4Attr() const;
  
      /// See GetDouble4Attr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateDouble4Attr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // POINT3H 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `point3h point3h = (0, 0, 0)` |
      /// | C++ Type | GfVec3h |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Point3h |
      USDCONTRIVED_API
      UsdAttribute GetPoint3hAttr() const;
  
      /// See GetPoint3hAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreatePoint3hAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // POINT3F 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `point3f point3f = (0, 0, 0)` |
      /// | C++ Type | GfVec3f |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Point3f |
      USDCONTRIVED_API
      UsdAttribute GetPoint3fAttr() const;
  
      /// See GetPoint3fAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreatePoint3fAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // POINT3D 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `point3d point3d = (0, 0, 0)` |
      /// | C++ Type | GfVec3d |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Point3d |
      USDCONTRIVED_API
      UsdAttribute GetPoint3dAttr() const;
  
      /// See GetPoint3dAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreatePoint3dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // VECTOR3D 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `vector3d vector3d = (0, 0, 0)` |
      /// | C++ Type | GfVec3d |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Vector3d |
      USDCONTRIVED_API
      UsdAttribute GetVector3dAttr() const;
  
      /// See GetVector3dAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateVector3dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // VECTOR3F 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `vector3f vector3f = (0, 0, 0)` |
      /// | C++ Type | GfVec3f |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Vector3f |
      USDCONTRIVED_API
      UsdAttribute GetVector3fAttr() const;
  
      /// See GetVector3fAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateVector3fAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // VECTOR3H 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `vector3h vector3h = (0, 0, 0)` |
      /// | C++ Type | GfVec3h |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Vector3h |
      USDCONTRIVED_API
      UsdAttribute GetVector3hAttr() const;
  
      /// See GetVector3hAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateVector3hAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // NORMAL3D 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `normal3d normal3d = (0, 0, 0)` |
      /// | C++ Type | GfVec3d |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Normal3d |
      USDCONTRIVED_API
      UsdAttribute GetNormal3dAttr() const;
  
      /// See GetNormal3dAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateNormal3dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // NORMAL3F 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `normal3f normal3f = (0, 0, 0)` |
      /// | C++ Type | GfVec3f |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Normal3f |
      USDCONTRIVED_API
      UsdAttribute GetNormal3fAttr() const;
  
      /// See GetNormal3fAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateNormal3fAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // NORMAL3H 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `normal3h normal3h = (0, 0, 0)` |
      /// | C++ Type | GfVec3h |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Normal3h |
      USDCONTRIVED_API
      UsdAttribute GetNormal3hAttr() const;
  
      /// See GetNormal3hAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateNormal3hAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // COLOR3D 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `color3d color3d = (0, 0, 0)` |
      /// | C++ Type | GfVec3d |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color3d |
      USDCONTRIVED_API
      UsdAttribute GetColor3dAttr() const;
  
      /// See GetColor3dAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateColor3dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // COLOR3F 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `color3f color3f = (0, 0, 0)` |
      /// | C++ Type | GfVec3f |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color3f |
      USDCONTRIVED_API
      UsdAttribute GetColor3fAttr() const;
  
      /// See GetColor3fAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateColor3fAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // COLOR3H 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `color3h color3h = (0, 0, 0)` |
      /// | C++ Type | GfVec3h |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color3h |
      USDCONTRIVED_API
      UsdAttribute GetColor3hAttr() const;
  
      /// See GetColor3hAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateColor3hAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // COLOR4D 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `color4d color4d = (0, 0, 0, 0)` |
      /// | C++ Type | GfVec4d |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color4d |
      USDCONTRIVED_API
      UsdAttribute GetColor4dAttr() const;
  
      /// See GetColor4dAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateColor4dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // COLOR4F 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `color4f color4f = (0, 0, 0, 0)` |
      /// | C++ Type | GfVec4f |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color4f |
      USDCONTRIVED_API
      UsdAttribute GetColor4fAttr() const;
  
      /// See GetColor4fAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateColor4fAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // COLOR4H 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `color4h color4h = (0, 0, 0, 0)` |
      /// | C++ Type | GfVec4h |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color4h |
      USDCONTRIVED_API
      UsdAttribute GetColor4hAttr() const;
  
      /// See GetColor4hAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateColor4hAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // QUATD 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `quatd quatd = (1, 0, 0, 0)` |
      /// | C++ Type | GfQuatd |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Quatd |
      USDCONTRIVED_API
      UsdAttribute GetQuatdAttr() const;
  
      /// See GetQuatdAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateQuatdAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // QUATF 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `quatf quatf = (1, 0, 0, 0)` |
      /// | C++ Type | GfQuatf |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Quatf |
      USDCONTRIVED_API
      UsdAttribute GetQuatfAttr() const;
  
      /// See GetQuatfAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateQuatfAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // QUATH 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `quath quath = (1, 0, 0, 0)` |
      /// | C++ Type | GfQuath |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Quath |
      USDCONTRIVED_API
      UsdAttribute GetQuathAttr() const;
  
      /// See GetQuathAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateQuathAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // MATRIX2D 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `matrix2d matrix2d = ( (1, 0), (0, 1) )` |
      /// | C++ Type | GfMatrix2d |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Matrix2d |
      USDCONTRIVED_API
      UsdAttribute GetMatrix2dAttr() const;
  
      /// See GetMatrix2dAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateMatrix2dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // MATRIX3D 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `matrix3d matrix3d = ( (1, 0, 0), (0, 1, 0), (0, 0, 1) )` |
      /// | C++ Type | GfMatrix3d |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Matrix3d |
      USDCONTRIVED_API
      UsdAttribute GetMatrix3dAttr() const;
  
      /// See GetMatrix3dAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateMatrix3dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // MATRIX4D 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `matrix4d matrix4d = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1) )` |
      /// | C++ Type | GfMatrix4d |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Matrix4d |
      USDCONTRIVED_API
      UsdAttribute GetMatrix4dAttr() const;
  
      /// See GetMatrix4dAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateMatrix4dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // FRAME4D 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `frame4d frame4d = ( (1, 0, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1) )` |
      /// | C++ Type | GfMatrix4d |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Frame4d |
      USDCONTRIVED_API
      UsdAttribute GetFrame4dAttr() const;
  
      /// See GetFrame4dAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateFrame4dAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // BOOLARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `bool[] boolArray` |
      /// | C++ Type | VtArray<bool> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->BoolArray |
      USDCONTRIVED_API
      UsdAttribute GetBoolArrayAttr() const;
  
      /// See GetBoolArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateBoolArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // UCHARARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `uchar[] ucharArray` |
      /// | C++ Type | VtArray<unsigned char> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->UCharArray |
      USDCONTRIVED_API
      UsdAttribute GetUcharArrayAttr() const;
  
      /// See GetUcharArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateUcharArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // INTARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `int[] intArray` |
      /// | C++ Type | VtArray<int> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->IntArray |
      USDCONTRIVED_API
      UsdAttribute GetIntArrayAttr() const;
  
      /// See GetIntArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateIntArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // UINTARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `uint[] uintArray` |
      /// | C++ Type | VtArray<unsigned int> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->UIntArray |
      USDCONTRIVED_API
      UsdAttribute GetUintArrayAttr() const;
  
      /// See GetUintArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateUintArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // INT64ARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `int64[] int64Array` |
      /// | C++ Type | VtArray<int64_t> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int64Array |
      USDCONTRIVED_API
      UsdAttribute GetInt64ArrayAttr() const;
  
      /// See GetInt64ArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateInt64ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // UINT64ARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `uint64[] uint64Array` |
      /// | C++ Type | VtArray<uint64_t> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->UInt64Array |
      USDCONTRIVED_API
      UsdAttribute GetUint64ArrayAttr() const;
  
      /// See GetUint64ArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateUint64ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // HALFARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `half[] halfArray` |
      /// | C++ Type | VtArray<GfHalf> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->HalfArray |
      USDCONTRIVED_API
      UsdAttribute GetHalfArrayAttr() const;
  
      /// See GetHalfArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateHalfArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // FLOATARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `float[] floatArray` |
      /// | C++ Type | VtArray<float> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->FloatArray |
      USDCONTRIVED_API
      UsdAttribute GetFloatArrayAttr() const;
  
      /// See GetFloatArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateFloatArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // DOUBLEARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `double[] doubleArray` |
      /// | C++ Type | VtArray<double> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->DoubleArray |
      USDCONTRIVED_API
      UsdAttribute GetDoubleArrayAttr() const;
  
      /// See GetDoubleArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateDoubleArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // STRINGARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `string[] stringArray` |
      /// | C++ Type | VtArray<std::string> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->StringArray |
      USDCONTRIVED_API
      UsdAttribute GetStringArrayAttr() const;
  
      /// See GetStringArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateStringArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // TOKENARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `token[] tokenArray` |
      /// | C++ Type | VtArray<TfToken> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->TokenArray |
      USDCONTRIVED_API
      UsdAttribute GetTokenArrayAttr() const;
  
      /// See GetTokenArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateTokenArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // ASSETARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `asset[] assetArray` |
      /// | C++ Type | VtArray<SdfAssetPath> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->AssetArray |
      USDCONTRIVED_API
      UsdAttribute GetAssetArrayAttr() const;
  
      /// See GetAssetArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateAssetArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // INT2ARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `int2[] int2Array` |
      /// | C++ Type | VtArray<GfVec2i> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int2Array |
      USDCONTRIVED_API
      UsdAttribute GetInt2ArrayAttr() const;
  
      /// See GetInt2ArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateInt2ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // INT3ARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `int3[] int3Array` |
      /// | C++ Type | VtArray<GfVec3i> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int3Array |
      USDCONTRIVED_API
      UsdAttribute GetInt3ArrayAttr() const;
  
      /// See GetInt3ArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateInt3ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // INT4ARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `int4[] int4Array` |
      /// | C++ Type | VtArray<GfVec4i> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Int4Array |
      USDCONTRIVED_API
      UsdAttribute GetInt4ArrayAttr() const;
  
      /// See GetInt4ArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateInt4ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // HALF2ARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `half2[] half2Array` |
      /// | C++ Type | VtArray<GfVec2h> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Half2Array |
      USDCONTRIVED_API
      UsdAttribute GetHalf2ArrayAttr() const;
  
      /// See GetHalf2ArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateHalf2ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // HALF3ARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `half3[] half3Array` |
      /// | C++ Type | VtArray<GfVec3h> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Half3Array |
      USDCONTRIVED_API
      UsdAttribute GetHalf3ArrayAttr() const;
  
      /// See GetHalf3ArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateHalf3ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // HALF4ARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `half4[] half4Array` |
      /// | C++ Type | VtArray<GfVec4h> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Half4Array |
      USDCONTRIVED_API
      UsdAttribute GetHalf4ArrayAttr() const;
  
      /// See GetHalf4ArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateHalf4ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // FLOAT2ARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `float2[] float2Array` |
      /// | C++ Type | VtArray<GfVec2f> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Float2Array |
      USDCONTRIVED_API
      UsdAttribute GetFloat2ArrayAttr() const;
  
      /// See GetFloat2ArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateFloat2ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // FLOAT3ARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `float3[] float3Array` |
      /// | C++ Type | VtArray<GfVec3f> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Float3Array |
      USDCONTRIVED_API
      UsdAttribute GetFloat3ArrayAttr() const;
  
      /// See GetFloat3ArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateFloat3ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // FLOAT4ARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `float4[] float4Array` |
      /// | C++ Type | VtArray<GfVec4f> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Float4Array |
      USDCONTRIVED_API
      UsdAttribute GetFloat4ArrayAttr() const;
  
      /// See GetFloat4ArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateFloat4ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // DOUBLE2ARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `double2[] double2Array` |
      /// | C++ Type | VtArray<GfVec2d> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double2Array |
      USDCONTRIVED_API
      UsdAttribute GetDouble2ArrayAttr() const;
  
      /// See GetDouble2ArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateDouble2ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // DOUBLE3ARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `double3[] double3Array` |
      /// | C++ Type | VtArray<GfVec3d> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double3Array |
      USDCONTRIVED_API
      UsdAttribute GetDouble3ArrayAttr() const;
  
      /// See GetDouble3ArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateDouble3ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // DOUBLE4ARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `double4[] double4Array` |
      /// | C++ Type | VtArray<GfVec4d> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Double4Array |
      USDCONTRIVED_API
      UsdAttribute GetDouble4ArrayAttr() const;
  
      /// See GetDouble4ArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateDouble4ArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // POINT3HARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `point3h[] point3hArray` |
      /// | C++ Type | VtArray<GfVec3h> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Point3hArray |
      USDCONTRIVED_API
      UsdAttribute GetPoint3hArrayAttr() const;
  
      /// See GetPoint3hArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreatePoint3hArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // POINT3FARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `point3f[] point3fArray` |
      /// | C++ Type | VtArray<GfVec3f> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Point3fArray |
      USDCONTRIVED_API
      UsdAttribute GetPoint3fArrayAttr() const;
  
      /// See GetPoint3fArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreatePoint3fArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // POINT3DARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `point3d[] point3dArray` |
      /// | C++ Type | VtArray<GfVec3d> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Point3dArray |
      USDCONTRIVED_API
      UsdAttribute GetPoint3dArrayAttr() const;
  
      /// See GetPoint3dArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreatePoint3dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // VECTOR3HARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `vector3h[] vector3hArray` |
      /// | C++ Type | VtArray<GfVec3h> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Vector3hArray |
      USDCONTRIVED_API
      UsdAttribute GetVector3hArrayAttr() const;
  
      /// See GetVector3hArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateVector3hArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // VECTOR3FARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `vector3f[] vector3fArray` |
      /// | C++ Type | VtArray<GfVec3f> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Vector3fArray |
      USDCONTRIVED_API
      UsdAttribute GetVector3fArrayAttr() const;
  
      /// See GetVector3fArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateVector3fArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // VECTOR3DARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `vector3d[] vector3dArray` |
      /// | C++ Type | VtArray<GfVec3d> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Vector3dArray |
      USDCONTRIVED_API
      UsdAttribute GetVector3dArrayAttr() const;
  
      /// See GetVector3dArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateVector3dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // NORMAL3HARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `normal3h[] normal3hArray` |
      /// | C++ Type | VtArray<GfVec3h> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Normal3hArray |
      USDCONTRIVED_API
      UsdAttribute GetNormal3hArrayAttr() const;
  
      /// See GetNormal3hArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateNormal3hArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // NORMAL3FARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `normal3f[] normal3fArray` |
      /// | C++ Type | VtArray<GfVec3f> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Normal3fArray |
      USDCONTRIVED_API
      UsdAttribute GetNormal3fArrayAttr() const;
  
      /// See GetNormal3fArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateNormal3fArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // NORMAL3DARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `normal3d[] normal3dArray` |
      /// | C++ Type | VtArray<GfVec3d> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Normal3dArray |
      USDCONTRIVED_API
      UsdAttribute GetNormal3dArrayAttr() const;
  
      /// See GetNormal3dArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateNormal3dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // COLOR3HARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `color3h[] color3hArray` |
      /// | C++ Type | VtArray<GfVec3h> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color3hArray |
      USDCONTRIVED_API
      UsdAttribute GetColor3hArrayAttr() const;
  
      /// See GetColor3hArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateColor3hArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // COLOR3FARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `color3f[] color3fArray` |
      /// | C++ Type | VtArray<GfVec3f> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color3fArray |
      USDCONTRIVED_API
      UsdAttribute GetColor3fArrayAttr() const;
  
      /// See GetColor3fArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateColor3fArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // COLOR3DARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `color3d[] color3dArray` |
      /// | C++ Type | VtArray<GfVec3d> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color3dArray |
      USDCONTRIVED_API
      UsdAttribute GetColor3dArrayAttr() const;
  
      /// See GetColor3dArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateColor3dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // COLOR4HARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `color4h[] color4hArray` |
      /// | C++ Type | VtArray<GfVec4h> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color4hArray |
      USDCONTRIVED_API
      UsdAttribute GetColor4hArrayAttr() const;
  
      /// See GetColor4hArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateColor4hArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // COLOR4FARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `color4f[] color4fArray` |
      /// | C++ Type | VtArray<GfVec4f> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color4fArray |
      USDCONTRIVED_API
      UsdAttribute GetColor4fArrayAttr() const;
  
      /// See GetColor4fArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateColor4fArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // COLOR4DARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `color4d[] color4dArray` |
      /// | C++ Type | VtArray<GfVec4d> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Color4dArray |
      USDCONTRIVED_API
      UsdAttribute GetColor4dArrayAttr() const;
  
      /// See GetColor4dArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateColor4dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // QUATHARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `quath[] quathArray` |
      /// | C++ Type | VtArray<GfQuath> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->QuathArray |
      USDCONTRIVED_API
      UsdAttribute GetQuathArrayAttr() const;
  
      /// See GetQuathArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateQuathArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // QUATFARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `quatf[] quatfArray` |
      /// | C++ Type | VtArray<GfQuatf> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->QuatfArray |
      USDCONTRIVED_API
      UsdAttribute GetQuatfArrayAttr() const;
  
      /// See GetQuatfArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateQuatfArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // QUATDARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `quatd[] quatdArray` |
      /// | C++ Type | VtArray<GfQuatd> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->QuatdArray |
      USDCONTRIVED_API
      UsdAttribute GetQuatdArrayAttr() const;
  
      /// See GetQuatdArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateQuatdArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // MATRIX2DARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `matrix2d[] matrix2dArray` |
      /// | C++ Type | VtArray<GfMatrix2d> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Matrix2dArray |
      USDCONTRIVED_API
      UsdAttribute GetMatrix2dArrayAttr() const;
  
      /// See GetMatrix2dArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateMatrix2dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // MATRIX3DARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `matrix3d[] matrix3dArray` |
      /// | C++ Type | VtArray<GfMatrix3d> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Matrix3dArray |
      USDCONTRIVED_API
      UsdAttribute GetMatrix3dArrayAttr() const;
  
      /// See GetMatrix3dArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateMatrix3dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // MATRIX4DARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `matrix4d[] matrix4dArray` |
      /// | C++ Type | VtArray<GfMatrix4d> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Matrix4dArray |
      USDCONTRIVED_API
      UsdAttribute GetMatrix4dArrayAttr() const;
  
      /// See GetMatrix4dArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateMatrix4dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // --------------------------------------------------------------------- //
      // FRAME4DARRAY 
      // --------------------------------------------------------------------- //
      /// 
      ///
      /// | ||
      /// | -- | -- |
      /// | Declaration | `frame4d[] frame4dArray` |
      /// | C++ Type | VtArray<GfMatrix4d> |
      /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Frame4dArray |
      USDCONTRIVED_API
      UsdAttribute GetFrame4dArrayAttr() const;
  
      /// See GetFrame4dArrayAttr(), and also 
      /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
      /// If specified, author \p defaultValue as the attribute's default,
      /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
      /// the default for \p writeSparsely is \c false.
      USDCONTRIVED_API
      UsdAttribute CreateFrame4dArrayAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
  
  public:
      // ===================================================================== //
      // Feel free to add custom code below this line, it will be preserved by 
      // the code generator. 
      //
      // Just remember to: 
      //  - Close the class declaration with }; 
      //  - Close the namespace with }
      //  - Close the include guard with #endif
      // ===================================================================== //
      // --(BEGIN CUSTOM CODE)--
  };
  
  }
  
  #endif
  