def Execute(result):
   result["GenerativeProceduralAPI"].__doc__ = """
This API extends and configures the core UsdProcGenerativeProcedural
schema defined within usdProc for use with hydra generative
procedurals as defined within hdGp.

For any described attribute *Fallback* *Value* or *Allowed* *Values*
below that are text/tokens, the actual token is published and defined
in UsdHydraTokens. So to set an attribute to the value"rightHanded",
use UsdHydraTokens->rightHanded as the value.

"""
   result["GenerativeProceduralAPI"].__init__.func_doc = """__init__(prim)


Construct a UsdHydraGenerativeProceduralAPI on UsdPrim ``prim`` .


Equivalent to UsdHydraGenerativeProceduralAPI::Get (prim.GetStage(),
prim.GetPath()) for a *valid* ``prim`` , but will not immediately
throw an error for an invalid ``prim``


Parameters
----------
prim : Prim



----------------------------------------------------------------------

__init__(schemaObj)


Construct a UsdHydraGenerativeProceduralAPI on the prim held by
``schemaObj`` .


Should be preferred over UsdHydraGenerativeProceduralAPI
(schemaObj.GetPrim()), as it preserves SchemaBase state.


Parameters
----------
schemaObj : SchemaBase


"""
   result["GenerativeProceduralAPI"].GetProceduralTypeAttr.func_doc = """GetProceduralTypeAttr() -> Attribute


The registered name of a HdGpGenerativeProceduralPlugin to be
executed.



Declaration

``token primvars:hdGp:proceduralType``

C++ Type

TfToken

Usd Type

SdfValueTypeNames->Token



"""
   result["GenerativeProceduralAPI"].CreateProceduralTypeAttr.func_doc = """CreateProceduralTypeAttr(defaultValue, writeSparsely) -> Attribute


See GetProceduralTypeAttr() , and also Create vs Get Property Methods
for when to use Get vs Create.


If specified, author ``defaultValue`` as the attribute's default,
sparsely (when it makes sense to do so) if ``writeSparsely`` is
``true`` - the default for ``writeSparsely`` is ``false`` .


Parameters
----------
defaultValue : VtValue

writeSparsely : bool


"""
   result["GenerativeProceduralAPI"].GetProceduralSystemAttr.func_doc = """GetProceduralSystemAttr() -> Attribute


This value should correspond to a configured instance of
HdGpGenerativeProceduralResolvingSceneIndex which will evaluate the
procedural.


The default value of"hydraGenerativeProcedural"matches the equivalent
default of HdGpGenerativeProceduralResolvingSceneIndex. Multiple
instances of the scene index can be used to determine where within a
scene index chain a given procedural will be evaluated.

Declaration

``token proceduralSystem ="hydraGenerativeProcedural"``

C++ Type

TfToken

Usd Type

SdfValueTypeNames->Token



"""
   result["GenerativeProceduralAPI"].CreateProceduralSystemAttr.func_doc = """CreateProceduralSystemAttr(defaultValue, writeSparsely) -> Attribute


See GetProceduralSystemAttr() , and also Create vs Get Property
Methods for when to use Get vs Create.


If specified, author ``defaultValue`` as the attribute's default,
sparsely (when it makes sense to do so) if ``writeSparsely`` is
``true`` - the default for ``writeSparsely`` is ``false`` .


Parameters
----------
defaultValue : VtValue

writeSparsely : bool


"""
   result["GenerativeProceduralAPI"].GetSchemaAttributeNames.func_doc = """**classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


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.


Parameters
----------
includeInherited : bool


"""
   result["GenerativeProceduralAPI"].Get.func_doc = """**classmethod** Get(stage, path) -> GenerativeProceduralAPI


Return a UsdHydraGenerativeProceduralAPI holding the prim adhering to
this schema at ``path`` on ``stage`` .


If no prim exists at ``path`` on ``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-block:: text

  UsdHydraGenerativeProceduralAPI(stage->GetPrimAtPath(path));



Parameters
----------
stage : Stage

path : Path


"""
   result["GenerativeProceduralAPI"].CanApply.func_doc = """**classmethod** CanApply(prim, whyNot) -> bool


Returns true if this **single-apply** API schema can be applied to the
given ``prim`` .


If this schema can not be a applied to the prim, this returns false
and, if provided, populates ``whyNot`` with the reason it can not be
applied.

Note that if CanApply returns false, that does not necessarily imply
that calling Apply will fail. Callers are expected to call CanApply
before calling Apply if they want to ensure that it is valid to apply
a schema.

UsdPrim::GetAppliedSchemas()

UsdPrim::HasAPI()

UsdPrim::CanApplyAPI()

UsdPrim::ApplyAPI()

UsdPrim::RemoveAPI()


Parameters
----------
prim : Prim

whyNot : str


"""
   result["GenerativeProceduralAPI"].Apply.func_doc = """**classmethod** Apply(prim) -> GenerativeProceduralAPI


Applies this **single-apply** API schema to the given ``prim`` .


This information is stored by adding"HydraGenerativeProceduralAPI"to
the token-valued, listOp metadata *apiSchemas* on the prim.

A valid UsdHydraGenerativeProceduralAPI object is returned upon
success. An invalid (or empty) UsdHydraGenerativeProceduralAPI object
is returned upon failure. See UsdPrim::ApplyAPI() for conditions
resulting in failure.

UsdPrim::GetAppliedSchemas()

UsdPrim::HasAPI()

UsdPrim::CanApplyAPI()

UsdPrim::ApplyAPI()

UsdPrim::RemoveAPI()


Parameters
----------
prim : Prim


"""
   result["GenerativeProceduralAPI"]._GetStaticTfType.func_doc = """**classmethod** _GetStaticTfType() -> Type



"""