xref: /dports/misc/usd/USD-21.11/pxr/usd/usd/testenv/testUsdSchemaGen/baseline/nestedNamespace/base.h

//
// 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 { namespace bar { namespace baz {

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;

    /// 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;

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, VariableTokenAllowed<3>, "" |
    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, VariableTokenArrayAllowed<3>, "" |
    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