Update .gitmodules to use https references rather than git reference (#297)

Co-authored-by: Michael Wilson <roflmuffin@users.noreply.github.com>

.github/workflows/cmake-single-platform.yml

@@ -4,9 +4,9 @@ on:
   push:
     paths-ignore:
       - 'docfx/**'
-    branches: [ "main" ]
+    branches: [ "main", "dev" ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ "main", "dev" ]
 
 env:
   BUILD_TYPE: Release
@@ -98,7 +98,7 @@ jobs:
         run: echo "GITHUB_SHA_SHORT=${GITHUB_SHA::7}" >> $GITHUB_ENV
 
       - name: Fallback build number
-        if: github.event_name == 'pull_request'
+        if: ${{ github.event_name == 'pull_request' || github.ref != 'refs/heads/main' }}
         shell: bash
         run: echo "BUILD_NUMBER=0" >> $GITHUB_ENV
 
@@ -106,7 +106,7 @@ jobs:
       - uses: actions/checkout@v3
 
       - name: Generate build number
-        if: github.event_name == 'push'
+        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
         id: buildnumber
         uses: onyxmueller/build-tag-number@v1
         with:
@@ -141,7 +141,7 @@ jobs:
           path: managed/CounterStrikeSharp.API/bin/Release
 
   publish:
-    if: github.event_name == 'push'
+    if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
     permissions:
       contents: write
     needs: [ "build_linux", "build_windows", "build_managed" ]
@@ -196,6 +196,7 @@ jobs:
           (cd build/windows && zip -qq -r ../../counterstrikesharp-with-runtime-build-${{ needs.build_managed.outputs.buildnumber }}-windows-${{ env.GITHUB_SHA_SHORT }}.zip *)
 
       - name: Release
+        id: release
         uses: softprops/action-gh-release@v1
         with:
           tag_name: v${{ needs.build_managed.outputs.buildnumber }}
@@ -208,4 +209,11 @@ jobs:
       - name: Publish NuGet package
         run: |
           dotnet nuget push build/api/CounterStrikeSharp.API.1.0.${{ needs.build_managed.outputs.buildnumber }}.nupkg --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json --skip-duplicate
-          dotnet nuget push build/api/CounterStrikeSharp.API.1.0.${{ needs.build_managed.outputs.buildnumber }}.snupkg --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json --skip-duplicate
+          dotnet nuget push build/api/CounterStrikeSharp.API.1.0.${{ needs.build_managed.outputs.buildnumber }}.snupkg --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json --skip-duplicate
+
+      - name: Send Notification to Discord
+        env:
+          DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}
+        uses: Ilshidur/action-discord@0.3.2
+        with:
+          args: "A new release of CS# has been tagged (v${{ needs.build_managed.outputs.buildnumber }}) at ${{ steps.release.outputs.url }}"

.gitmodules

@@ -19,7 +19,7 @@
 	url = https://github.com/SteamDatabase/GameTracking-CS2
 [submodule "libraries/DynoHook"]
 	path = libraries/DynoHook
-	url = git@github.com:qubka/DynoHook.git
+	url = https://github.com/qubka/DynoHook
 [submodule "libraries/asmjit"]
 	path = libraries/asmjit
-	url = git@github.com:asmjit/asmjit.git
+	url = https://github.com/asmjit/asmjit

CODEOWNERS

@@ -0,0 +1 @@
+* @roflmuffin

README.md

@@ -128,4 +128,4 @@ Build
 ```bash
 cmake --build . --config Debug
 ```
-
+<img src="https://repobeats.axiom.co/api/embed/a96f228b8fa98c032070fa8dd831c967334ee553.svg" width="100%" />

configs/addons/counterstrikesharp/gamedata/gamedata.json

@@ -22,28 +22,28 @@
   },
   "CCSPlayerController_ChangeTeam": {
     "offsets": {
-      "windows": 90,
-      "linux": 89
+      "windows": 93,
+      "linux": 92
     }
   },
   "CCSPlayerController_Respawn": {
     "offsets": {
-        "windows": 242,
-        "linux": 244
+        "windows": 245,
+        "linux": 247
     }
   },
-  "CCSPlayerPawn_Respawn": {
+  "CBasePlayerController_SetPawn": {
     "signatures": {
-        "library": "server",
-        "windows": "\\x40\\x53\\x48\\x83\\xEC\\x20\\x8B\\x91\\x38\\x0B\\x00\\x00\\x48\\x8B\\xD9",
-        "linux": "\\x8B\\x8F\\x40\\x0E\\x00\\x00\\x83\\xF9\\xFF\\x0F\\x84\\xD9\\x01"
+      "library": "server",
+      "windows": "\\x44\\x88\\x4C\\x24\\x20\\x55\\x57\\x41\\x54\\x41\\x56\\x41\\x57\\x48\\x8D\\x6C\\x24\\x2A\\x48\\x81\\xEC\\x2A",
+      "linux": "\\x55\\x48\\x89\\xE5\\x41\\x57\\x41\\x56\\x41\\x55\\x41\\x54\\x49\\x89\\xFC\\x53\\x48\\x89\\xF3\\x48\\x81\\xEC\\xC8\\x00\\x00\\x00"
     }
   },
   "CCSPlayerPawnBase_PostThink": {
     "signatures": {
       "library": "server",
       "windows": "\\x48\\x8B\\xC4\\x48\\x89\\x48\\x08\\x55\\x53\\x56\\x57\\x41\\x56\\x48\\x8D\\xA8\\xD8\\xFE\\xFF\\xFF",
-      "linux": "\\x55\\x48\\x89\\xE5\\x41\\x57\\x49\\x89\\xFF\\x41\\x56\\x41\\x55\\x41\\x54\\x53\\x48\\x81\\xEC\\x2A\\x2A\\x2A\\x2A\\xE8\\x2A\\x2A\\x2A\\x2A\\x4C"
+      "linux": "\\x55\\x48\\x89\\xE5\\x41\\x57\\x41\\x56\\x41\\x55\\x41\\x54\\x53\\x48\\x89\\xFB\\x48\\x81\\xEC\\x2A\\x2A\\x2A\\x2A\\xE8\\x2A\\x2A\\x2A\\x2A\\x48\\x89\\xDF"
     }
   },
   "GiveNamedItem": {
@@ -70,8 +70,15 @@
   "CBaseModelEntity_SetModel": {
     "signatures": {
         "library": "server",
-        "windows": "\\x48\\x89\\x5C\\x24\\x10\\x48\\x89\\x7C\\x24\\x20\\x55\\x48\\x8B\\xEC\\x48\\x83\\xEC\\x50",
-        "linux": "\\x55\\x48\\x89\\xF2\\x48\\x89\\xE5\\x41\\x54\\x49\\x89\\xFC\\x48\\x8D\\x2A\\x2A\\x48\\x83\\x2A\\x2A\\x2A\\x8D\\x05\\x2A\\x2A\\x2A\\x00\\x48\\x8B\\x30\\x48\\x8B\\x06\\xFF\\x2A\\x2A\\x48\\x8B\\x45\\x2A\\x48\\x8D\\x2A\\x2A\\x4C\\x89\\x2A\\x48\\x89\\x45\\x2A\\x2A\\x68\\xFC"
+        "windows": "\\x48\\x89\\x5C\\x24\\x2A\\x48\\x89\\x7C\\x24\\x2A\\x55\\x48\\x8B\\xEC\\x48\\x83\\xEC\\x50\\x48\\x8B\\xF9\\x4C\\x8B\\xC2",
+        "linux": "\\x55\\x48\\x89\\xF2\\x48\\x89\\xE5\\x41\\x54\\x49\\x89\\xFC\\x48\\x8D\\x7D\\xE0\\x48\\x83\\xEC\\x2A\\x48\\x8D\\x05\\x2A\\x2A\\x2A\\x2A\\x48\\x8B\\x30\\x48\\x8B\\x06"
+    }
+  },
+  "CCSPlayer_WeaponServices_CanUse": {
+    "signatures": {
+      "library": "server",
+      "windows": "\\x48\\x89\\x5C\\x24\\x10\\x48\\x89\\x6C\\x24\\x18\\x56\\x57\\x41\\x56\\x48\\x83\\xEC\\x30\\x80\\xB9\\xA0\\x00\\x00\\x00\\x00",
+      "linux": "\\x48\\x85\\xF6\\x0F\\x84\\x2A\\x2A\\x2A\\x2A\\x55\\x31\\xC9\\x48\\x89\\xE5\\x41\\x55\\x49\\x89\\xFD"
     }
   },
   "CCSPlayer_ItemServices_DropActivePlayerWeapon": {
@@ -82,7 +89,7 @@
   },
   "CCSPlayer_ItemServices_RemoveWeapons": {
       "offsets": {
-          "windows": 21,
+          "windows": 19,
           "linux": 20
       }
   },
@@ -95,14 +102,14 @@
   "CCSGameRules_TerminateRound": {
     "signatures": {
         "library": "server",
-        "windows": "\\x48\\x8B\\xC4\\x4C\\x89\\x48\\x20\\x55\\x56",
-        "linux": "\\x55\\x48\\x89\\xE5\\x41\\x57\\x41\\x56\\x41\\x55\\x49\\x89\\xFD\\x41\\x54\\x53\\x48\\x81\\xEC\\xE8"
+        "windows": "\\x48\\x8B\\xC4\\x4C\\x89\\x48\\x20\\x55\\x57",
+        "linux": "\\x55\\x48\\x89\\xE5\\x41\\x57\\x41\\x56\\x41\\x55\\x41\\x54\\x49\\x89\\xFC\\x53\\x48\\x81\\xEC\\xE8\\x01\\x00\\x00\\x48\\x8D\\x05\\x2A\\x2A\\x2A\\x2A"
       }
   },
   "UTIL_CreateEntityByName": {
     "signatures": {
         "library": "server",
-        "windows": "\\x48\\x83\\xEC\\x48\\xC6\\x44\\x24\\x30\\x00\\x4C\\x8B\\xC1",
+        "windows": "\\x48\\x83\\xEC\\x48\\xC6\\x44\\x24\\x30\\x00",
         "linux": "\\x48\\x8D\\x05\\x2A\\x2A\\x2A\\x2A\\x55\\x48\\x89\\xFA"
       }
   },
@@ -110,9 +117,16 @@
     "signatures": {
         "library": "server",
         "windows": "\\x48\\x89\\x5C\\x24\\x10\\x57\\x48\\x83\\xEC\\x30\\x48\\x8B\\xDA\\x48\\x8B\\xF9\\x48\\x85\\xC9",
-        "linux": "\\x48\\x85\\xFF\\x74\\x4B\\x55\\x48\\x89\\xE5\\x41\\x56"
+        "linux": "\\x48\\x85\\xFF\\x74\\x2A\\x55\\x48\\x89\\xE5\\x41\\x56"
       }
   },
+  "CEntityInstance_AcceptInput": {
+    "signatures": {
+      "library": "server",
+      "windows": "\\x48\\x89\\x5C\\x24\\x10\\x48\\x89\\x74\\x24\\x18\\x57\\x48\\x83\\xEC\\x40\\x49\\x8B\\xF0",
+      "linux": "\\x55\\x48\\x89\\xE5\\x41\\x57\\x49\\x89\\xFF\\x41\\x56\\x48\\x8D\\x7D\\xC0"
+    }
+  },
   "LegacyGameEventListener": {
     "signatures": {
       "library": "server",
@@ -122,8 +136,8 @@
   },
   "CBasePlayerPawn_CommitSuicide": {
     "offsets": {
-      "windows": 357,
-      "linux": 357
+      "windows": 360,
+      "linux": 360
     }
   },
   "CBasePlayerPawn_RemovePlayerItem": {
@@ -157,7 +171,21 @@
     "signatures": {
       "library": "server",
       "windows": "\\x40\\x53\\x57\\x41\\x55\\x48\\x83\\xEC\\x40",
-      "linux": "\\x55\\xBA\\xFF\\xFF\\xFF\\xFF\\x48\\x89\\xE5\\x41\\x57\\x41\\x56\\x41\\x55\\x49"
+      "linux": "\\x55\\xBA\\xFF\\xFF\\xFF\\xFF\\x48\\x89\\xE5\\x41\\x57\\x41\\x56\\x41\\x55\\x49\\x89\\xF5\\x41"
+    }
+  },
+  "StateChanged": {
+    "signatures": {
+      "library": "server",
+      "windows": "\\x40\\x55\\x53\\x56\\x41\\x55\\x41\\x57\\x48\\x8D\\x6C\\x24\\xB0",
+      "linux": "\\x55\\x48\\x89\\xE5\\x41\\x57\\x41\\x56\\x41\\x55\\x41\\x54\\x53\\x89\\xD3"
+    }
+  },
+  "NetworkStateChanged": {
+    "signatures": {
+      "library": "server",
+      "windows": "\\x4C\\x8B\\xC9\\x48\\x8B\\x09\\x48\\x85\\xC9\\x74\\x2A\\x48\\x8B\\x41\\x10",
+      "linux": "\\x4C\\x8B\\x07\\x4D\\x85\\xC0\\x74\\x2A\\x49\\x8B\\x40\\x10"
     }
   },
   "GameEntitySystem": {
@@ -168,15 +196,15 @@
   },
   "GameEventManager": {
     "offsets": {
-      "windows": 91,
-      "linux": 91
+      "windows": 93,
+      "linux": 93
     }
   },
   "CEntityIOOutput_FireOutputInternal": {
     "signatures": {
       "library": "server",
-      "windows": "\\x48\\x8B\\xC4\\x4C\\x89\\x48\\x20\\x55\\x57\\x41\\x54\\x41\\x56",
-      "linux": "\\x55\\x48\\x89\\xE5\\x41\\x57\\x41\\x56\\x41\\x55\\x41\\x54\\x53\\x48\\x83\\xEC\\x58\\x4C\\x8B\\x6F\\x08"
+      "windows": "\\x4C\\x89\\x4C\\x24\\x20\\x53\\x55\\x57\\x41\\x54\\x41\\x56\\x48\\x81\\xEC",
+      "linux": "\\x55\\x48\\x89\\xE5\\x41\\x57\\x41\\x56\\x41\\x55\\x41\\x54\\x49\\x89\\xD4\\x53\\x48\\x89\\xF3\\x48\\x83\\xEC\\x58"
     }
   }
-}
+}

configs/addons/counterstrikesharp/gamedata/schema_enums.txt

@@ -1,305 +1,320 @@
-ActionType_t
-AimMatrixBlendMode
-AmmoFlags_t
-AmmoPosition_t
-AnimLoopMode_t
-AnimNodeNetworkMode
-AnimParamButton_t
-AnimParamNetworkSetting
-AnimParamType_t
-AnimPoseControl
-AnimScriptType
-AnimVRFinger_t
-AnimVRHandMotionRange_t
-AnimVRHand_t
-AnimValueSource
-AnimVectorSource
-AnimVrBoneTransformSource_t
-AnimVrFingerSplay_t
-AnimationProcessingType_t
-AnimationSnapshotType_t
-AnimationType_t
-BBoxVolumeType_t
-BaseExplosionTypes_t
-BeamClipStyle_t
-BeamType_t
-BeginDeathLifeStateTransition_t
-BinaryNodeChildOption
-BinaryNodeTiming
-Blend2DMode
-BlendKeyType
-BloomBlendMode_t
-BlurFilterType_t
-BoneMaskBlendSpace
-BoneTransformSpace_t
-BrushSolidities_e
-CAnimationGraphVisualizerPrimitiveType
-CLogicBranchList__LogicBranchListenerLastState_t
-CRR_Response__ResponseEnum_t
-CSPlayerBlockingUseAction_t
-CSPlayerState
-CSWeaponCategory
-CSWeaponMode
-CSWeaponSilencerType
-CSWeaponState_t
-CSWeaponType
-CanPlaySequence_t
-ChatIgnoreType_t
-ChickenActivity
-ChoiceBlendMethod
-ChoiceChangeMethod
-ChoiceMethod
-Class_T
-ClosestPointTestType_t
-CommandEntitySpecType_t
-CommandExecMode_t
-CompMatPropertyMutatorConditionType_t
-CompMatPropertyMutatorType_t
-CompositeMaterialInputContainerSourceType_t
-CompositeMaterialInputLooseVariableType_t
-CompositeMaterialInputTextureType_t
-CompositeMaterialMatchFilterType_t
-CompositeMaterialVarSystemVar_t
-DamageTypes_t
-DampingSpeedFunction
-DebugOverlayBits_t
-Detail2Combo_t
-DetailCombo_t
-DisableShadows_t
-Disposition_t
-DoorState_t
-EDemoBoneSelectionMode
-EGrenadeThrowState
-EInButtonState
-EKillTypes_t
-ELayoutNodeType
-EOverrideBlockLOS_t
-EStyleNodeType
-EntFinderMethod_t
-EntityDisolveType_t
-EntityDormancyType_t
-EntityIOTargetType_t
-EntitySubclassScope_t
-Explosions
-FacingMode
-FieldNetworkOption
-FixAngleSet_t
-FlexOpCode_t
-FootFallTagFoot_t
-FootLockSubVisualization
-FootPinningTimingSource
-FootstepLandedFootSoundType_t
-ForcedCrouchState_t
-FuncDoorSpawnPos_t
-FuseVariableAccess_t
-FuseVariableType_t
-GameAnimEventIndex_t
-GrenadeType_t
-HierarchyType_t
-HitGroup_t
-HitboxLerpType_t
-HorizJustification_e
-Hull_t
-IChoreoServices__ChoreoState_t
-IChoreoServices__ScriptState_t
-IKChannelMode
-IKSolverType
-IKTargetCoordinateSystem
-IKTargetSource
-IkEndEffectorType
-IkTargetType
-InheritableBoolType_t
-InputBitMask_t
-InputLayoutVariation_t
-ItemFlagTypes_t
-JiggleBoneSimSpace
-JointAxis_t
-JointMotion_t
-JumpCorrectionMethod
-LatchDirtyPermission_t
-LayoutPositionType_e
-LessonPanelLayoutFileTypes_t
-LifeState_t
-MaterialProxyType_t
-Materials
-MatterialAttributeTagType_t
-MedalRank_t
-MeshDrawPrimitiveFlags_t
-MissingParentInheritBehavior_t
-ModelBoneFlexComponent_t
-ModelConfigAttachmentType_t
-ModelSkeletonData_t__BoneFlags_t
-ModifyDamageReturn_t
-MoodType_t
-MorphBundleType_t
-MorphFlexControllerRemapType_t
-MoveCollide_t
-MoveLinearAuthoredPos_t
-MoveMountingAmount_t
-MoveType_t
-NavAttributeEnum
-NavDirType
-ObjectTypeFlags_t
-ObserverInterpState_t
-ObserverMode_t
-OnFrame
-PFNoiseModifier_t
-PFNoiseTurbulence_t
-PFNoiseType_t
-PFuncVisualizationType_t
-ParticleAlphaReferenceType_t
-ParticleAttachment_t
-ParticleCollisionMode_t
-ParticleColorBlendMode_t
-ParticleColorBlendType_t
-ParticleControlPointAxis_t
-ParticleDepthFeatheringMode_t
-ParticleDetailLevel_t
-ParticleDirectionNoiseType_t
-ParticleEndcapMode_t
-ParticleFalloffFunction_t
-ParticleFloatBiasType_t
-ParticleFloatInputMode_t
-ParticleFloatMapType_t
-ParticleFloatRandomMode_t
-ParticleFloatType_t
-ParticleFogType_t
-ParticleHitboxBiasType_t
-ParticleHitboxDataSelection_t
-ParticleImpulseType_t
-ParticleLightBehaviorChoiceList_t
-ParticleLightFogLightingMode_t
-ParticleLightTypeChoiceList_t
-ParticleLightUnitChoiceList_t
-ParticleLightingQuality_t
-ParticleLightnintBranchBehavior_t
-ParticleModelType_t
-ParticleOmni2LightTypeChoiceList_t
-ParticleOrientationChoiceList_t
-ParticleOrientationSetMode_t
-ParticleOutputBlendMode_t
-ParticleParentSetMode_t
-ParticlePinDistance_t
-ParticlePostProcessPriorityGroup_t
-ParticleRotationLockType_t
-ParticleSelection_t
-ParticleSequenceCropOverride_t
-ParticleSetMethod_t
-ParticleSortingChoiceList_t
-ParticleTextureLayerBlendType_t
-ParticleTopology_t
-ParticleTraceMissBehavior_t
-ParticleTraceSet_t
-ParticleTransformType_t
-ParticleVRHandChoiceList_t
-ParticleVecType_t
-PerformanceMode_t
-PermModelInfo_t__FlagEnum
-PetGroundType_t
-PlayerAnimEvent_t
-PlayerConnectedState
-PointTemplateClientOnlyEntityBehavior_t
-PointTemplateOwnerSpawnGroupType_t
-PointWorldTextJustifyHorizontal_t
-PointWorldTextJustifyVertical_t
-PointWorldTextReorientMode_t
-PoseType_t
-PropDoorRotatingOpenDirection_e
-PropDoorRotatingSpawnPos_t
-PulseInstructionCode_t
-PulseMethodCallMode_t
-PulseValueType_t
-QuestProgress__Reason
-RagdollPoseControl
-RenderBufferFlags_t
-RenderFx_t
-RenderMode_t
-RenderMultisampleType_t
-RenderPrimitiveType_t
-RenderSlotType_t
-ResetCycleOption
-RumbleEffect_t
-ScalarExpressionType_t
-SceneOnPlayerDeath_t
-ScriptedConflictResponse_t
-ScriptedMoveTo_t
-ScriptedMoveType_t
-ScriptedOnDeath_t
-SelectorTagBehavior_t
-SeqCmd_t
-SeqPoseSetting_t
-ShadowType_t
-ShakeCommand_t
-ShardSolid_t
-ShatterDamageCause
-ShatterGlassStressType
-ShatterPanelMode
-SimpleConstraintSoundProfile__SimpleConstraintsSoundProfileKeypoints_t
-SolidType_t
-SolveIKChainAnimNodeDebugSetting
-SosActionSortType_t
-SosActionStopType_t
-SosEditItemType_t
-SosGroupType_t
-SoundEventStartType_t
-SoundFlags_t
-SpawnDebugOverrideState_t
-SpawnDebugRestrictionOverrideState_t
-SpawnPointCoopEnemy__BotDefaultBehavior_t
-SpriteCardPerParticleScale_t
-SpriteCardShaderType_t
-SpriteCardTextureChannel_t
-SpriteCardTextureType_t
-StanceOverrideMode
-StanceType_t
-StandardLightingAttenuationStyle_t
-StateActionBehavior
-StepPhase
-SubclassVDataChangeType_t
-SurroundingBoundsType_t
-TOGGLE_STATE
-TRAIN_CODE
-TakeDamageFlags_t
-TextureRepetitionMode_t
-ThreeState_t
-TimelineCompression_t
-Touch_t
-TrackOrientationType_t
-TrainOrientationType_t
-TrainVelocityType_t
-VMixChannelOperation_t
-VMixFilterSlope_t
-VMixFilterType_t
-VMixLFOShape_t
-VMixPannerType_t
-VMixProcessorType_t
-VMixSubgraphSwitchInterpolationType_t
-VPhysXAggregateData_t__VPhysXFlagEnum_t
-VPhysXBodyPart_t__VPhysXFlagEnum_t
-VPhysXConstraintParams_t__EnumFlags0_t
-VPhysXJoint_t__Flags_t
-ValueRemapperHapticsType_t
-ValueRemapperInputType_t
-ValueRemapperMomentumType_t
-ValueRemapperOutputType_t
-ValueRemapperRatchetType_t
-VectorExpressionType_t
-VectorFloatExpressionType_t
-VelocityMetricMode
-VertJustification_e
-ViewFadeMode_t
-WaterLevel_t
-WeaponAttackType_t
-WeaponSound_t
-WorldTextPanelHorizontalAlign_t
-WorldTextPanelOrientation_t
-WorldTextPanelVerticalAlign_t
-attributeprovidertypes_t
-doorCheck_e
-fieldtype_t
-filter_t
-gear_slot_t
-loadout_slot_t
-navproperties_t
-soundlevel_t
-vote_create_failed_t
+ActionType_t
+AimMatrixBlendMode
+AmmoFlags_t
+AmmoPosition_t
+AnimationProcessingType_t
+AnimationSnapshotType_t
+AnimationType_t
+AnimLoopMode_t
+AnimNodeNetworkMode
+AnimParamButton_t
+AnimParamNetworkSetting
+AnimParamType_t
+AnimPoseControl
+AnimScriptType
+AnimValueSource
+AnimVectorSource
+attributeprovidertypes_t
+BaseExplosionTypes_t
+BBoxVolumeType_t
+BeamClipStyle_t
+BeamType_t
+BeginDeathLifeStateTransition_t
+BinaryNodeChildOption
+BinaryNodeTiming
+Blend2DMode
+BlendKeyType
+BloomBlendMode_t
+BlurFilterType_t
+BoneMaskBlendSpace
+BoneTransformSpace_t
+BrushSolidities_e
+C4LightEffect_t
+CAnimationGraphVisualizerPrimitiveType
+CanPlaySequence_t
+ChatIgnoreType_t
+ChickenActivity
+ChoiceBlendMethod
+ChoiceChangeMethod
+ChoiceMethod
+Class_T
+CLogicBranchList__LogicBranchListenerLastState_t
+ClosestPointTestType_t
+CNmBoneMask__WeightInfo_t
+CommandEntitySpecType_t
+CommandExecMode_t
+CompMatPropertyMutatorConditionType_t
+CompMatPropertyMutatorType_t
+CompositeMaterialInputContainerSourceType_t
+CompositeMaterialInputLooseVariableType_t
+CompositeMaterialInputTextureType_t
+CompositeMaterialMatchFilterType_t
+CompositeMaterialVarSystemVar_t
+CRR_Response__ResponseEnum_t
+CSPlayerBlockingUseAction_t
+CSPlayerState
+CSWeaponCategory
+CSWeaponMode
+CSWeaponSilencerType
+CSWeaponState_t
+CSWeaponType
+DamageTypes_t
+DampingSpeedFunction
+DebugOverlayBits_t
+Detail2Combo_t
+DetailCombo_t
+DisableShadows_t
+Disposition_t
+doorCheck_e
+DoorState_t
+EDemoBoneSelectionMode
+EInButtonState
+EKillTypes_t
+ELayoutNodeType
+EntFinderMethod_t
+EntityDisolveType_t
+EntityDormancyType_t
+EntityIOTargetType_t
+EntitySubclassScope_t
+EOverrideBlockLOS_t
+EStyleNodeType
+Explosions
+FacingMode
+FieldNetworkOption
+fieldtype_t
+filter_t
+FixAngleSet_t
+FlexOpCode_t
+FootFallTagFoot_t
+FootLockSubVisualization
+FootPinningTimingSource
+FootstepLandedFootSoundType_t
+ForcedCrouchState_t
+FuncDoorSpawnPos_t
+FuseVariableAccess_t
+FuseVariableType_t
+GameAnimEventIndex_t
+gear_slot_t
+GrenadeType_t
+HierarchyType_t
+HitboxLerpType_t
+HitGroup_t
+HorizJustification_e
+Hull_t
+IChoreoServices__ChoreoState_t
+IChoreoServices__ScriptState_t
+IKChannelMode
+IkEndEffectorType
+IKSolverType
+IKTargetCoordinateSystem
+IKTargetSource
+IkTargetType
+InheritableBoolType_t
+InputBitMask_t
+InputLayoutVariation_t
+ItemFlagTypes_t
+JiggleBoneSimSpace
+JointAxis_t
+JointMotion_t
+JumpCorrectionMethod
+LatchDirtyPermission_t
+LayoutPositionType_e
+LessonPanelLayoutFileTypes_t
+LifeState_t
+loadout_slot_t
+MaterialProxyType_t
+Materials
+MatterialAttributeTagType_t
+MedalRank_t
+MeshDrawPrimitiveFlags_t
+MissingParentInheritBehavior_t
+ModelBoneFlexComponent_t
+ModelConfigAttachmentType_t
+ModelSkeletonData_t__BoneFlags_t
+ModifyDamageReturn_t
+MoodType_t
+MorphBundleType_t
+MorphFlexControllerRemapType_t
+MoveCollide_t
+MoveLinearAuthoredPos_t
+MovementGait_t
+MoveMountingAmount_t
+MoveType_t
+NavAttributeEnum
+NavDirType
+navproperties_t
+NmFootPhase_t
+NmFootPhaseCondition_t
+NmFrameSnapEventMode_t
+NmTransitionRule_t
+NmTransitionRuleCondition_t
+NPCFollowFormation_t
+NPCLookType_t
+ObjectTypeFlags_t
+ObserverInterpState_t
+ObserverMode_t
+OnFrame
+ParticleAlphaReferenceType_t
+ParticleAttachment_t
+ParticleAttrBoxFlags_t
+ParticleCollisionMode_t
+ParticleColorBlendMode_t
+ParticleColorBlendType_t
+ParticleControlPointAxis_t
+ParticleDepthFeatheringMode_t
+ParticleDetailLevel_t
+ParticleDirectionNoiseType_t
+ParticleEndcapMode_t
+ParticleFalloffFunction_t
+ParticleFloatBiasType_t
+ParticleFloatInputMode_t
+ParticleFloatMapType_t
+ParticleFloatRandomMode_t
+ParticleFloatType_t
+ParticleFogType_t
+ParticleHitboxBiasType_t
+ParticleHitboxDataSelection_t
+ParticleImpulseType_t
+ParticleLightBehaviorChoiceList_t
+ParticleLightFogLightingMode_t
+ParticleLightingQuality_t
+ParticleLightnintBranchBehavior_t
+ParticleLightTypeChoiceList_t
+ParticleLightUnitChoiceList_t
+ParticleModelType_t
+ParticleOmni2LightTypeChoiceList_t
+ParticleOrientationChoiceList_t
+ParticleOrientationSetMode_t
+ParticleOutputBlendMode_t
+ParticleParentSetMode_t
+ParticlePinDistance_t
+ParticlePostProcessPriorityGroup_t
+ParticleRotationLockType_t
+ParticleSelection_t
+ParticleSequenceCropOverride_t
+ParticleSetMethod_t
+ParticleSortingChoiceList_t
+ParticleTextureLayerBlendType_t
+ParticleTopology_t
+ParticleTraceMissBehavior_t
+ParticleTraceSet_t
+ParticleTransformType_t
+ParticleVecType_t
+ParticleVRHandChoiceList_t
+PerformanceMode_t
+PermModelInfo_t__FlagEnum
+PetGroundType_t
+PFNoiseModifier_t
+PFNoiseTurbulence_t
+PFNoiseType_t
+PFuncVisualizationType_t
+PlayerAnimEvent_t
+PlayerConnectedState
+PointTemplateClientOnlyEntityBehavior_t
+PointTemplateOwnerSpawnGroupType_t
+PointWorldTextJustifyHorizontal_t
+PointWorldTextJustifyVertical_t
+PointWorldTextReorientMode_t
+PoseType_t
+PreviewCharacterMode
+PreviewEOMCelebration
+PreviewWeaponState
+PropDoorRotatingOpenDirection_e
+PropDoorRotatingSpawnPos_t
+PulseCursorCancelPriority_t
+PulseCursorExecResult_t
+PulseInstructionCode_t
+PulseMethodCallMode_t
+PulseTestEnumColor_t
+PulseTestEnumShape_t
+PulseValueType_t
+QuestProgress__Reason
+RagdollPoseControl
+RenderBufferFlags_t
+RenderFx_t
+RenderMode_t
+RenderMultisampleType_t
+RenderPrimitiveType_t
+RenderSlotType_t
+ResetCycleOption
+RumbleEffect_t
+ScalarExpressionType_t
+SceneOnPlayerDeath_t
+ScriptedConflictResponse_t
+ScriptedMoveTo_t
+ScriptedMoveType_t
+ScriptedOnDeath_t
+SelectorTagBehavior_t
+SeqCmd_t
+SeqPoseSetting_t
+SequenceFinishNotifyState_t
+ShadowType_t
+ShakeCommand_t
+ShardSolid_t
+ShatterDamageCause
+ShatterGlassStressType
+ShatterPanelMode
+SimpleConstraintSoundProfile__SimpleConstraintsSoundProfileKeypoints_t
+SnapshotIndexType_t
+SolidType_t
+SolveIKChainAnimNodeDebugSetting
+SosActionSortType_t
+SosActionStopType_t
+SosEditItemType_t
+SosGroupType_t
+SoundEventStartType_t
+SoundFlags_t
+soundlevel_t
+SpawnDebugOverrideState_t
+SpawnDebugRestrictionOverrideState_t
+SpawnPointCoopEnemy__BotDefaultBehavior_t
+SpriteCardPerParticleScale_t
+SpriteCardShaderType_t
+SpriteCardTextureChannel_t
+SpriteCardTextureType_t
+StanceOverrideMode
+StanceType_t
+StandardLightingAttenuationStyle_t
+StateActionBehavior
+StepPhase
+SubclassVDataChangeType_t
+SurroundingBoundsType_t
+TakeDamageFlags_t
+TextureRepetitionMode_t
+ThreeState_t
+TimelineCompression_t
+TOGGLE_STATE
+Touch_t
+TrackOrientationType_t
+TRAIN_CODE
+TrainOrientationType_t
+TrainVelocityType_t
+ValueRemapperHapticsType_t
+ValueRemapperInputType_t
+ValueRemapperMomentumType_t
+ValueRemapperOutputType_t
+ValueRemapperRatchetType_t
+VectorExpressionType_t
+VectorFloatExpressionType_t
+VelocityMetricMode
+VertJustification_e
+ViewFadeMode_t
+VMixChannelOperation_t
+VMixFilterSlope_t
+VMixFilterType_t
+VMixLFOShape_t
+VMixPannerType_t
+VMixProcessorType_t
+VMixSubgraphSwitchInterpolationType_t
+vote_create_failed_t
+VPhysXAggregateData_t__VPhysXFlagEnum_t
+VPhysXBodyPart_t__VPhysXFlagEnum_t
+VPhysXConstraintParams_t__EnumFlags0_t
+VPhysXJoint_t__Flags_t
+WaterLevel_t
+WeaponAttackType_t
+WeaponSound_t
+WeaponSwitchReason_t
+WorldTextPanelHorizontalAlign_t
+WorldTextPanelOrientation_t
+WorldTextPanelVerticalAlign_t

managed/CounterStrikeSharp.API.Tests/AdminTests.cs

@@ -27,9 +27,9 @@ public class AdminTests
     {
         var adminData = AdminManager.GetPlayerAdminData((SteamID)76561197960265731);
         Assert.NotNull(adminData);
-        Assert.Equal(125u, adminData.Immunity); // Group immunity is 125, Admin immunity is 100
+        Assert.Equal(125u, AdminManager.GetPlayerImmunity((SteamID)76561197960265731)); // Group immunity is 125, Admin immunity is 100
         AdminManager.SetPlayerImmunity((SteamID)76561197960265731, 150u);
-        Assert.Equal(150u, adminData.Immunity); // Group immunity is 125, Admin immunity is 100
+        Assert.Equal(150u, AdminManager.GetPlayerImmunity((SteamID)76561197960265731)); // Group immunity is 125, Admin immunity is 100
     }
     
     [Fact]

managed/CounterStrikeSharp.API/Core/API.cs

@@ -312,6 +312,16 @@ namespace CounterStrikeSharp.API.Core
 			}
 		}
 
+        public static int GetMaxClients(){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x5DF2E20D);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			return (int)ScriptContext.GlobalScriptContext.GetResult(typeof(int));
+			}
+		}
+
         public static void IssueServerCommand(string command){
 			lock (ScriptContext.GlobalScriptContext.Lock) {
 			ScriptContext.GlobalScriptContext.Reset();
@@ -1064,6 +1074,18 @@ namespace CounterStrikeSharp.API.Core
 			}
 		}
 
+        public static bool IsSchemaFieldNetworked(string classname, string propname){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(classname);
+			ScriptContext.GlobalScriptContext.Push(propname);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0xFE413B0C);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			return (bool)ScriptContext.GlobalScriptContext.GetResult(typeof(bool));
+			}
+		}
+
         public static T GetSchemaValueByName<T>(IntPtr instance, int returntype, string classname, string propname){
 			lock (ScriptContext.GlobalScriptContext.Lock) {
 			ScriptContext.GlobalScriptContext.Reset();

managed/CounterStrikeSharp.API/Core/Application.cs

@@ -85,11 +85,12 @@ namespace CounterStrikeSharp.API.Core
 
             for (var i = 1; i <= 9; i++)
             {
-                CommandUtils.AddStandaloneCommand("css_" + i, "Command Key Handler", (player, info) =>
+                CommandUtils.AddStandaloneCommand($"css_{i}", "Command Key Handler", (player, info) =>
                 {
                     if (player == null) return;
                     var key = Convert.ToInt32(info.GetArg(0).Split("_")[1]);
-                    ChatMenus.OnKeyPress(player, key);
+                    
+                    MenuManager.OnKeyPress(player, key);
                 });
             }
 
@@ -151,7 +152,7 @@ namespace CounterStrikeSharp.API.Core
                 case "start":
                 case "load":
                 {
-                    if (info.ArgCount < 2)
+                    if (info.ArgCount < 3)
                     {
                         info.ReplyToCommand(
                             "Valid usage: css_plugins start/load [relative plugin path || absolute plugin path] (e.g \"TestPlugin\", \"plugins/TestPlugin/TestPlugin.dll\")\n",
@@ -181,7 +182,8 @@ namespace CounterStrikeSharp.API.Core
                         }
                         catch (Exception e)
                         {
-                            info.ReplyToCommand($"Could not load plugin \"{path}\")", true);
+                            info.ReplyToCommand($"Could not load plugin \"{path}\"", true);
+                            Logger.LogError(e, "Could not load plugin \"{Path}\"", path);
                         }
                     }
                     else
@@ -195,7 +197,7 @@ namespace CounterStrikeSharp.API.Core
                 case "stop":
                 case "unload":
                 {
-                    if (info.ArgCount < 2)
+                    if (info.ArgCount < 3)
                     {
                         info.ReplyToCommand(
                             "Valid usage: css_plugins stop/unload [plugin name || #plugin id] (e.g \"TestPlugin\", \"1\")\n",
@@ -207,7 +209,7 @@ namespace CounterStrikeSharp.API.Core
                     IPluginContext? plugin = _pluginContextQueryHandler.FindPluginByIdOrName(pluginIdentifier);
                     if (plugin == null)
                     {
-                        info.ReplyToCommand($"Could not unload plugin \"{pluginIdentifier}\")", true);
+                        info.ReplyToCommand($"Could not unload plugin \"{pluginIdentifier}\"", true);
                         break;
                     }
 
@@ -218,7 +220,7 @@ namespace CounterStrikeSharp.API.Core
                 case "restart":
                 case "reload":
                 {
-                    if (info.ArgCount < 2)
+                    if (info.ArgCount < 3)
                     {
                         info.ReplyToCommand(
                             "Valid usage: css_plugins restart/reload [plugin name || #plugin id] (e.g \"TestPlugin\", \"#1\")\n",
@@ -231,7 +233,7 @@ namespace CounterStrikeSharp.API.Core
 
                     if (plugin == null)
                     {
-                        info.ReplyToCommand($"Could not reload plugin \"{pluginIdentifier}\")", true);
+                        info.ReplyToCommand($"Could not reload plugin \"{pluginIdentifier}\"", true);
                         break;
                     }
 
@@ -288,7 +290,7 @@ namespace CounterStrikeSharp.API.Core
             CommandUtils.AddStandaloneCommand("css", "Counter-Strike Sharp options.", OnCSSCommand);
             CommandUtils.AddStandaloneCommand("css_plugins", "Counter-Strike Sharp plugin options.",
                 OnCSSPluginCommand);
-            CommandUtils.AddStandaloneCommand("css_lang", "Set Counter-Strike Sharp language", OnLangCommand);
+            CommandUtils.AddStandaloneCommand("css_lang", "Set Counter-Strike Sharp language.", OnLangCommand);
         }
     }
 }

managed/CounterStrikeSharp.API/Core/Model/CBaseEntity.cs

@@ -27,5 +27,5 @@ public partial class CBaseEntity
     /// </summary>
     public QAngle? AbsRotation => CBodyComponent?.SceneNode?.AbsRotation;
 
-    public T? GetVData<T>() where T : CEntitySubclassVDataBase => (T)Activator.CreateInstance(typeof(T),  Marshal.ReadIntPtr(SubclassID.Handle + 8));
+    public T? GetVData<T>() where T : CEntitySubclassVDataBase => (T)Activator.CreateInstance(typeof(T),  Marshal.ReadIntPtr(SubclassID.Handle + 4));
 }

managed/CounterStrikeSharp.API/Core/Model/CBasePlayerController.cs

@@ -0,0 +1,19 @@
+using System;
+
+using CounterStrikeSharp.API.Modules.Cvars;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Entities.Constants;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBasePlayerController
+{
+	public void SetPawn(CBasePlayerPawn? pawn)
+	{
+		if (pawn is null) return;
+		if (!pawn.IsValid) return;
+		VirtualFunctions.CBasePlayerController_SetPawnFunc.Invoke(this, pawn, true, false);
+	}
+}

managed/CounterStrikeSharp.API/Core/Model/CCSPlayerController.cs

@@ -10,17 +10,13 @@ namespace CounterStrikeSharp.API.Core;
 
 public partial class CCSPlayerController
 {
-    public int? UserId
-    {
-        get
-        {
-            return NativeAPI.GetUseridFromIndex((int)this.Index);
-        }
-    }
+    public int? UserId => NativeAPI.GetUseridFromIndex((int)Index);
+    public CsTeam Team => (CsTeam)TeamNum;
 
     public IntPtr GiveNamedItem(string item)
     {
         if (!PlayerPawn.IsValid) return 0;
+        if (PlayerPawn.Value == null) return 0;
         if (!PlayerPawn.Value.IsValid) return 0;
         if (PlayerPawn.Value.ItemServices == null) return 0;
 
@@ -35,7 +31,7 @@ public partial class CCSPlayerController
             return IntPtr.Zero;
         }
 
-        return this.GiveNamedItem(itemString);
+        return GiveNamedItem(itemString);
     }
 
     public void PrintToConsole(string message)
@@ -45,12 +41,12 @@ public partial class CCSPlayerController
 
     public void PrintToChat(string message)
     {
-        VirtualFunctions.ClientPrint(this.Handle, HudDestination.Chat, message, 0, 0, 0, 0);
+        VirtualFunctions.ClientPrint(Handle, HudDestination.Chat, message, 0, 0, 0, 0);
     }
 
     public void PrintToCenter(string message)
     {
-        VirtualFunctions.ClientPrint(this.Handle, HudDestination.Center, message, 0, 0, 0, 0);
+        VirtualFunctions.ClientPrint(Handle, HudDestination.Center, message, 0, 0, 0, 0);
     }
 
     public void PrintToCenterHtml(string message) => PrintToCenterHtml(message, 5);
@@ -72,14 +68,16 @@ public partial class CCSPlayerController
     public void DropActiveWeapon()
     {
         if (!PlayerPawn.IsValid) return;
+        if (PlayerPawn.Value == null) return;
         if (!PlayerPawn.Value.IsValid) return;
         if (PlayerPawn.Value.ItemServices == null) return;
         if (PlayerPawn.Value.WeaponServices == null) return;
         if (!PlayerPawn.Value.WeaponServices.ActiveWeapon.IsValid) return;
 
         CCSPlayer_ItemServices itemServices = new CCSPlayer_ItemServices(PlayerPawn.Value.ItemServices.Handle);
-        CCSPlayer_WeaponServices weponServices = new CCSPlayer_WeaponServices(PlayerPawn.Value.WeaponServices.Handle);
-        itemServices.DropActivePlayerWeapon(weponServices.ActiveWeapon.Value);
+        CCSPlayer_WeaponServices weaponServices = new CCSPlayer_WeaponServices(PlayerPawn.Value.WeaponServices.Handle);
+        
+        itemServices.DropActivePlayerWeapon(weaponServices.ActiveWeapon.Value);
     }
 
     /// <summary>
@@ -88,6 +86,7 @@ public partial class CCSPlayerController
     public void RemoveWeapons()
     {
         if (!PlayerPawn.IsValid) return;
+        if (PlayerPawn.Value == null) return;
         if (!PlayerPawn.Value.IsValid) return;
         if (PlayerPawn.Value.ItemServices == null) return;
 
@@ -103,6 +102,7 @@ public partial class CCSPlayerController
     public void CommitSuicide(bool explode, bool force)
     {
         if (!PlayerPawn.IsValid) return;
+        if (PlayerPawn.Value == null) return;
         if (!PlayerPawn.Value.IsValid) return;
 
         PlayerPawn.Value.CommitSuicide(explode, force);
@@ -114,9 +114,11 @@ public partial class CCSPlayerController
     public void Respawn()
     {
         if (!PlayerPawn.IsValid) return;
+        if (PlayerPawn.Value == null) return;
         if (!PlayerPawn.Value.IsValid) return;
 
-        VirtualFunctions.CCSPlayerPawn_Respawn(PlayerPawn.Value.Handle);
+        // The Call To Arms update appears to have invalidated the need for CCSPlayerPawn_Respawn.
+        SetPawn(PlayerPawn.Value);
         VirtualFunction.CreateVoid<IntPtr>(Handle, GameData.GetOffset("CCSPlayerController_Respawn"))(Handle);
     }
 
@@ -128,7 +130,7 @@ public partial class CCSPlayerController
     /// <param name="team">The team to switch to</param>
     public void SwitchTeam(CsTeam team)
     {
-        VirtualFunctions.SwitchTeam(this.Handle, (byte)team);
+        VirtualFunctions.SwitchTeam(Handle, (byte)team);
     }
 
     /// <summary>
@@ -151,7 +153,7 @@ public partial class CCSPlayerController
     /// <returns>ConVar string value</returns>
     public string GetConVarValue(string conVar)
     {
-        return NativeAPI.GetClientConvarValue(this.Slot, conVar);
+        return NativeAPI.GetClientConvarValue(Slot, conVar);
     }
 
     public string GetConVarValue(ConVar? conVar)
@@ -177,7 +179,7 @@ public partial class CCSPlayerController
             throw new InvalidOperationException("'SetFakeClientConVar' can only be called for fake clients (bots)");
         }
 
-        NativeAPI.SetFakeClientConvarValue(this.Slot, conVar, value);
+        NativeAPI.SetFakeClientConvarValue(Slot, conVar, value);
     }
 
     /// <summary>
@@ -226,8 +228,8 @@ public partial class CCSPlayerController
     {
         get
         {
-            if (!this.IsValid) return null;
-            var authorizedSteamId = NativeAPI.GetPlayerAuthorizedSteamid(this.Slot);
+            if (!IsValid) return null;
+            var authorizedSteamId = NativeAPI.GetPlayerAuthorizedSteamid(Slot);
             if ((long)authorizedSteamId == -1) return null;
 
             return (SteamID)authorizedSteamId;
@@ -242,8 +244,8 @@ public partial class CCSPlayerController
     {
         get
         {
-            if (!this.IsValid) return null;
-            var ipAddress = NativeAPI.GetPlayerIpAddress(this.Slot);
+            if (!IsValid) return null;
+            var ipAddress = NativeAPI.GetPlayerIpAddress(Slot);
             if (string.IsNullOrWhiteSpace(ipAddress)) return null;
 
             return ipAddress;
@@ -256,9 +258,6 @@ public partial class CCSPlayerController
     public VoiceFlags VoiceFlags
     {
         get => (VoiceFlags)NativeAPI.GetClientVoiceFlags(Handle);
-        set
-        {
-            NativeAPI.SetClientVoiceFlags(Handle, (Byte)value);
-        }
+        set => NativeAPI.SetClientVoiceFlags(Handle, (Byte)value);
     }
-}
+}

managed/CounterStrikeSharp.API/Core/Model/CCSPlayerPawn.cs

@@ -1,19 +1,21 @@
 using System;
 using CounterStrikeSharp.API.Modules.Memory;
+using Microsoft.Extensions.Logging;
 
 namespace CounterStrikeSharp.API.Core;
 
 public partial class CCSPlayerPawn
 {
-    /// <summary>
-    /// Respawn player
-    /// </summary>
-    public void Respawn()
-    {
-        if (!Controller.IsValid) return;
-        if (!Controller.Value.IsValid) return;
+	/// <summary>
+	/// Respawn player
+	/// </summary>
 
-        VirtualFunctions.CCSPlayerPawn_Respawn(Handle);
-        VirtualFunction.CreateVoid<IntPtr>(Controller.Value.Handle, GameData.GetOffset("CCSPlayerController_Respawn"))(Controller.Value.Handle);
-    }
-}
+	[Obsolete("Use CCSPlayerController.Respawn() instead")]
+	public void Respawn()
+	{
+		if (!Controller.IsValid) return;
+		if (!Controller.Value.IsValid) return;
+
+		Application.Instance.Logger.LogWarning("CCSPawn.Respawn is deprecated and does nothing, use CCSPlayerController.Respawn instead");
+	}
+}

managed/CounterStrikeSharp.API/Core/Model/CEntityInstance.cs

@@ -58,6 +58,24 @@ public partial class CEntityInstance : IEquatable<CEntityInstance>
     {
         return !Equals(left, right);
     }
+    
+    /// <summary>
+    /// Calls a named input method on an entity.
+    /// <example>
+    /// <code>
+    /// entity.AcceptInput("Break");
+    /// </code>
+    /// </example>
+    /// </summary>
+    /// <param name="inputName">Input action name</param>
+    /// <param name="activator">Entity which initiated the action, <see langword="null"/> for no entity</param>
+    /// <param name="caller">Entity that is sending the event, <see langword="null"/> for no entity</param>
+    /// <param name="value">String variant value to send with the event</param>
+    /// <param name="outputId">Unknown, defaults to 0</param>
+    public void AcceptInput(string inputName, CEntityInstance? activator = null, CEntityInstance? caller = null, string value = "", int outputId = 0)
+    {
+        VirtualFunctions.AcceptInput(Handle, inputName, activator?.Handle ?? IntPtr.Zero, caller?.Handle ?? IntPtr.Zero, value, 0);
+    }
 }
 
 public partial class CEntityIdentity

managed/CounterStrikeSharp.API/Core/Schema/Classes/CAISound.g.cs

@@ -0,0 +1,49 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CAISound : CPointEntity
+{
+    public CAISound (IntPtr pointer) : base(pointer) {}
+
+	// m_iSoundType
+	[SchemaMember("CAISound", "m_iSoundType")]
+	public ref Int32 SoundType => ref Schema.GetRef<Int32>(this.Handle, "CAISound", "m_iSoundType");
+
+	// m_iSoundContext
+	[SchemaMember("CAISound", "m_iSoundContext")]
+	public ref Int32 SoundContext => ref Schema.GetRef<Int32>(this.Handle, "CAISound", "m_iSoundContext");
+
+	// m_iVolume
+	[SchemaMember("CAISound", "m_iVolume")]
+	public ref Int32 Volume => ref Schema.GetRef<Int32>(this.Handle, "CAISound", "m_iVolume");
+
+	// m_iSoundIndex
+	[SchemaMember("CAISound", "m_iSoundIndex")]
+	public ref Int32 SoundIndex => ref Schema.GetRef<Int32>(this.Handle, "CAISound", "m_iSoundIndex");
+
+	// m_flDuration
+	[SchemaMember("CAISound", "m_flDuration")]
+	public ref float Duration => ref Schema.GetRef<float>(this.Handle, "CAISound", "m_flDuration");
+
+	// m_iszProxyEntityName
+	[SchemaMember("CAISound", "m_iszProxyEntityName")]
+	public string ProxyEntityName
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CAISound", "m_iszProxyEntityName"); }
+		set { Schema.SetString(this.Handle, "CAISound", "m_iszProxyEntityName", value); }
+	}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CAI_ChangeHintGroup.g.cs

@@ -0,0 +1,45 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CAI_ChangeHintGroup : CBaseEntity
+{
+    public CAI_ChangeHintGroup (IntPtr pointer) : base(pointer) {}
+
+	// m_iSearchType
+	[SchemaMember("CAI_ChangeHintGroup", "m_iSearchType")]
+	public ref Int32 SearchType => ref Schema.GetRef<Int32>(this.Handle, "CAI_ChangeHintGroup", "m_iSearchType");
+
+	// m_strSearchName
+	[SchemaMember("CAI_ChangeHintGroup", "m_strSearchName")]
+	public string StrSearchName
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CAI_ChangeHintGroup", "m_strSearchName"); }
+		set { Schema.SetString(this.Handle, "CAI_ChangeHintGroup", "m_strSearchName", value); }
+	}
+
+	// m_strNewHintGroup
+	[SchemaMember("CAI_ChangeHintGroup", "m_strNewHintGroup")]
+	public string StrNewHintGroup
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CAI_ChangeHintGroup", "m_strNewHintGroup"); }
+		set { Schema.SetString(this.Handle, "CAI_ChangeHintGroup", "m_strNewHintGroup", value); }
+	}
+
+	// m_flRadius
+	[SchemaMember("CAI_ChangeHintGroup", "m_flRadius")]
+	public ref float Radius => ref Schema.GetRef<float>(this.Handle, "CAI_ChangeHintGroup", "m_flRadius");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CAI_Expresser.g.cs

@@ -0,0 +1,57 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CAI_Expresser : NativeObject
+{
+    public CAI_Expresser (IntPtr pointer) : base(pointer) {}
+
+	// m_flStopTalkTime
+	[SchemaMember("CAI_Expresser", "m_flStopTalkTime")]
+	public ref float StopTalkTime => ref Schema.GetRef<float>(this.Handle, "CAI_Expresser", "m_flStopTalkTime");
+
+	// m_flStopTalkTimeWithoutDelay
+	[SchemaMember("CAI_Expresser", "m_flStopTalkTimeWithoutDelay")]
+	public ref float StopTalkTimeWithoutDelay => ref Schema.GetRef<float>(this.Handle, "CAI_Expresser", "m_flStopTalkTimeWithoutDelay");
+
+	// m_flBlockedTalkTime
+	[SchemaMember("CAI_Expresser", "m_flBlockedTalkTime")]
+	public ref float BlockedTalkTime => ref Schema.GetRef<float>(this.Handle, "CAI_Expresser", "m_flBlockedTalkTime");
+
+	// m_voicePitch
+	[SchemaMember("CAI_Expresser", "m_voicePitch")]
+	public ref Int32 VoicePitch => ref Schema.GetRef<Int32>(this.Handle, "CAI_Expresser", "m_voicePitch");
+
+	// m_flLastTimeAcceptedSpeak
+	[SchemaMember("CAI_Expresser", "m_flLastTimeAcceptedSpeak")]
+	public ref float LastTimeAcceptedSpeak => ref Schema.GetRef<float>(this.Handle, "CAI_Expresser", "m_flLastTimeAcceptedSpeak");
+
+	// m_bAllowSpeakingInterrupts
+	[SchemaMember("CAI_Expresser", "m_bAllowSpeakingInterrupts")]
+	public ref bool AllowSpeakingInterrupts => ref Schema.GetRef<bool>(this.Handle, "CAI_Expresser", "m_bAllowSpeakingInterrupts");
+
+	// m_bConsiderSceneInvolvementAsSpeech
+	[SchemaMember("CAI_Expresser", "m_bConsiderSceneInvolvementAsSpeech")]
+	public ref bool ConsiderSceneInvolvementAsSpeech => ref Schema.GetRef<bool>(this.Handle, "CAI_Expresser", "m_bConsiderSceneInvolvementAsSpeech");
+
+	// m_nLastSpokenPriority
+	[SchemaMember("CAI_Expresser", "m_nLastSpokenPriority")]
+	public ref Int32 LastSpokenPriority => ref Schema.GetRef<Int32>(this.Handle, "CAI_Expresser", "m_nLastSpokenPriority");
+
+	// m_pOuter
+	[SchemaMember("CAI_Expresser", "m_pOuter")]
+	public CBaseFlex? Outer => Schema.GetPointer<CBaseFlex>(this.Handle, "CAI_Expresser", "m_pOuter");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CAI_ExpresserWithFollowup.g.cs

@@ -0,0 +1,25 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CAI_ExpresserWithFollowup : CAI_Expresser
+{
+    public CAI_ExpresserWithFollowup (IntPtr pointer) : base(pointer) {}
+
+	// m_pPostponedFollowup
+	[SchemaMember("CAI_ExpresserWithFollowup", "m_pPostponedFollowup")]
+	public ResponseFollowup? PostponedFollowup => Schema.GetPointer<ResponseFollowup>(this.Handle, "CAI_ExpresserWithFollowup", "m_pPostponedFollowup");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CAK47.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CAK47 : CCSWeaponBaseGun
+{
+    public CAK47 (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CAmbientGeneric.g.cs

@@ -0,0 +1,69 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CAmbientGeneric : CPointEntity
+{
+    public CAmbientGeneric (IntPtr pointer) : base(pointer) {}
+
+	// m_radius
+	[SchemaMember("CAmbientGeneric", "m_radius")]
+	public ref float Radius => ref Schema.GetRef<float>(this.Handle, "CAmbientGeneric", "m_radius");
+
+	// m_flMaxRadius
+	[SchemaMember("CAmbientGeneric", "m_flMaxRadius")]
+	public ref float MaxRadius => ref Schema.GetRef<float>(this.Handle, "CAmbientGeneric", "m_flMaxRadius");
+
+	// m_iSoundLevel
+	[SchemaMember("CAmbientGeneric", "m_iSoundLevel")]
+	public ref soundlevel_t SoundLevel => ref Schema.GetRef<soundlevel_t>(this.Handle, "CAmbientGeneric", "m_iSoundLevel");
+
+	// m_dpv
+	[SchemaMember("CAmbientGeneric", "m_dpv")]
+	public dynpitchvol_t Dpv => Schema.GetDeclaredClass<dynpitchvol_t>(this.Handle, "CAmbientGeneric", "m_dpv");
+
+	// m_fActive
+	[SchemaMember("CAmbientGeneric", "m_fActive")]
+	public ref bool Active => ref Schema.GetRef<bool>(this.Handle, "CAmbientGeneric", "m_fActive");
+
+	// m_fLooping
+	[SchemaMember("CAmbientGeneric", "m_fLooping")]
+	public ref bool Looping => ref Schema.GetRef<bool>(this.Handle, "CAmbientGeneric", "m_fLooping");
+
+	// m_iszSound
+	[SchemaMember("CAmbientGeneric", "m_iszSound")]
+	public string Sound
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CAmbientGeneric", "m_iszSound"); }
+		set { Schema.SetString(this.Handle, "CAmbientGeneric", "m_iszSound", value); }
+	}
+
+	// m_sSourceEntName
+	[SchemaMember("CAmbientGeneric", "m_sSourceEntName")]
+	public string SourceEntName
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CAmbientGeneric", "m_sSourceEntName"); }
+		set { Schema.SetString(this.Handle, "CAmbientGeneric", "m_sSourceEntName", value); }
+	}
+
+	// m_hSoundSource
+	[SchemaMember("CAmbientGeneric", "m_hSoundSource")]
+	public CHandle<CBaseEntity> SoundSource => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CAmbientGeneric", "m_hSoundSource");
+
+	// m_nSoundSourceEntIndex
+	[SchemaMember("CAmbientGeneric", "m_nSoundSourceEntIndex")]
+	public CEntityIndex SoundSourceEntIndex => Schema.GetDeclaredClass<CEntityIndex>(this.Handle, "CAmbientGeneric", "m_nSoundSourceEntIndex");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CAnimGraphNetworkedVariables.g.cs

@@ -0,0 +1,117 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CAnimGraphNetworkedVariables : NativeObject
+{
+    public CAnimGraphNetworkedVariables (IntPtr pointer) : base(pointer) {}
+
+	// m_PredNetBoolVariables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_PredNetBoolVariables")]
+	public NetworkedVector<UInt32> PredNetBoolVariables => Schema.GetDeclaredClass<NetworkedVector<UInt32>>(this.Handle, "CAnimGraphNetworkedVariables", "m_PredNetBoolVariables");
+
+	// m_PredNetByteVariables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_PredNetByteVariables")]
+	public NetworkedVector<byte> PredNetByteVariables => Schema.GetDeclaredClass<NetworkedVector<byte>>(this.Handle, "CAnimGraphNetworkedVariables", "m_PredNetByteVariables");
+
+	// m_PredNetUInt16Variables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_PredNetUInt16Variables")]
+	public NetworkedVector<UInt16> PredNetUInt16Variables => Schema.GetDeclaredClass<NetworkedVector<UInt16>>(this.Handle, "CAnimGraphNetworkedVariables", "m_PredNetUInt16Variables");
+
+	// m_PredNetIntVariables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_PredNetIntVariables")]
+	public NetworkedVector<Int32> PredNetIntVariables => Schema.GetDeclaredClass<NetworkedVector<Int32>>(this.Handle, "CAnimGraphNetworkedVariables", "m_PredNetIntVariables");
+
+	// m_PredNetUInt32Variables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_PredNetUInt32Variables")]
+	public NetworkedVector<UInt32> PredNetUInt32Variables => Schema.GetDeclaredClass<NetworkedVector<UInt32>>(this.Handle, "CAnimGraphNetworkedVariables", "m_PredNetUInt32Variables");
+
+	// m_PredNetUInt64Variables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_PredNetUInt64Variables")]
+	public NetworkedVector<UInt64> PredNetUInt64Variables => Schema.GetDeclaredClass<NetworkedVector<UInt64>>(this.Handle, "CAnimGraphNetworkedVariables", "m_PredNetUInt64Variables");
+
+	// m_PredNetFloatVariables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_PredNetFloatVariables")]
+	public NetworkedVector<float> PredNetFloatVariables => Schema.GetDeclaredClass<NetworkedVector<float>>(this.Handle, "CAnimGraphNetworkedVariables", "m_PredNetFloatVariables");
+
+	// m_PredNetVectorVariables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_PredNetVectorVariables")]
+	public NetworkedVector<Vector> PredNetVectorVariables => Schema.GetDeclaredClass<NetworkedVector<Vector>>(this.Handle, "CAnimGraphNetworkedVariables", "m_PredNetVectorVariables");
+
+	// m_PredNetQuaternionVariables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_PredNetQuaternionVariables")]
+	public NetworkedVector<Quaternion> PredNetQuaternionVariables => Schema.GetDeclaredClass<NetworkedVector<Quaternion>>(this.Handle, "CAnimGraphNetworkedVariables", "m_PredNetQuaternionVariables");
+
+	// m_PredNetGlobalSymbolVariables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_PredNetGlobalSymbolVariables")]
+	public NetworkedVector<string> PredNetGlobalSymbolVariables => Schema.GetDeclaredClass<NetworkedVector<string>>(this.Handle, "CAnimGraphNetworkedVariables", "m_PredNetGlobalSymbolVariables");
+
+	// m_OwnerOnlyPredNetBoolVariables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetBoolVariables")]
+	public NetworkedVector<UInt32> OwnerOnlyPredNetBoolVariables => Schema.GetDeclaredClass<NetworkedVector<UInt32>>(this.Handle, "CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetBoolVariables");
+
+	// m_OwnerOnlyPredNetByteVariables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetByteVariables")]
+	public NetworkedVector<byte> OwnerOnlyPredNetByteVariables => Schema.GetDeclaredClass<NetworkedVector<byte>>(this.Handle, "CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetByteVariables");
+
+	// m_OwnerOnlyPredNetUInt16Variables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetUInt16Variables")]
+	public NetworkedVector<UInt16> OwnerOnlyPredNetUInt16Variables => Schema.GetDeclaredClass<NetworkedVector<UInt16>>(this.Handle, "CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetUInt16Variables");
+
+	// m_OwnerOnlyPredNetIntVariables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetIntVariables")]
+	public NetworkedVector<Int32> OwnerOnlyPredNetIntVariables => Schema.GetDeclaredClass<NetworkedVector<Int32>>(this.Handle, "CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetIntVariables");
+
+	// m_OwnerOnlyPredNetUInt32Variables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetUInt32Variables")]
+	public NetworkedVector<UInt32> OwnerOnlyPredNetUInt32Variables => Schema.GetDeclaredClass<NetworkedVector<UInt32>>(this.Handle, "CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetUInt32Variables");
+
+	// m_OwnerOnlyPredNetUInt64Variables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetUInt64Variables")]
+	public NetworkedVector<UInt64> OwnerOnlyPredNetUInt64Variables => Schema.GetDeclaredClass<NetworkedVector<UInt64>>(this.Handle, "CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetUInt64Variables");
+
+	// m_OwnerOnlyPredNetFloatVariables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetFloatVariables")]
+	public NetworkedVector<float> OwnerOnlyPredNetFloatVariables => Schema.GetDeclaredClass<NetworkedVector<float>>(this.Handle, "CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetFloatVariables");
+
+	// m_OwnerOnlyPredNetVectorVariables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetVectorVariables")]
+	public NetworkedVector<Vector> OwnerOnlyPredNetVectorVariables => Schema.GetDeclaredClass<NetworkedVector<Vector>>(this.Handle, "CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetVectorVariables");
+
+	// m_OwnerOnlyPredNetQuaternionVariables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetQuaternionVariables")]
+	public NetworkedVector<Quaternion> OwnerOnlyPredNetQuaternionVariables => Schema.GetDeclaredClass<NetworkedVector<Quaternion>>(this.Handle, "CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetQuaternionVariables");
+
+	// m_OwnerOnlyPredNetGlobalSymbolVariables
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetGlobalSymbolVariables")]
+	public NetworkedVector<string> OwnerOnlyPredNetGlobalSymbolVariables => Schema.GetDeclaredClass<NetworkedVector<string>>(this.Handle, "CAnimGraphNetworkedVariables", "m_OwnerOnlyPredNetGlobalSymbolVariables");
+
+	// m_nBoolVariablesCount
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_nBoolVariablesCount")]
+	public ref Int32 BoolVariablesCount => ref Schema.GetRef<Int32>(this.Handle, "CAnimGraphNetworkedVariables", "m_nBoolVariablesCount");
+
+	// m_nOwnerOnlyBoolVariablesCount
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_nOwnerOnlyBoolVariablesCount")]
+	public ref Int32 OwnerOnlyBoolVariablesCount => ref Schema.GetRef<Int32>(this.Handle, "CAnimGraphNetworkedVariables", "m_nOwnerOnlyBoolVariablesCount");
+
+	// m_nRandomSeedOffset
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_nRandomSeedOffset")]
+	public ref Int32 RandomSeedOffset => ref Schema.GetRef<Int32>(this.Handle, "CAnimGraphNetworkedVariables", "m_nRandomSeedOffset");
+
+	// m_flLastTeleportTime
+	[SchemaMember("CAnimGraphNetworkedVariables", "m_flLastTeleportTime")]
+	public ref float LastTeleportTime => ref Schema.GetRef<float>(this.Handle, "CAnimGraphNetworkedVariables", "m_flLastTeleportTime");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CAttributeContainer.g.cs

@@ -0,0 +1,25 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CAttributeContainer : CAttributeManager
+{
+    public CAttributeContainer (IntPtr pointer) : base(pointer) {}
+
+	// m_Item
+	[SchemaMember("CAttributeContainer", "m_Item")]
+	public CEconItemView Item => Schema.GetDeclaredClass<CEconItemView>(this.Handle, "CAttributeContainer", "m_Item");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CAttributeList.g.cs

@@ -0,0 +1,29 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CAttributeList : NativeObject
+{
+    public CAttributeList (IntPtr pointer) : base(pointer) {}
+
+	// m_Attributes
+	[SchemaMember("CAttributeList", "m_Attributes")]
+	public NetworkedVector<CEconItemAttribute> Attributes => Schema.GetDeclaredClass<NetworkedVector<CEconItemAttribute>>(this.Handle, "CAttributeList", "m_Attributes");
+
+	// m_pManager
+	[SchemaMember("CAttributeList", "m_pManager")]
+	public CAttributeManager? Manager => Schema.GetPointer<CAttributeManager>(this.Handle, "CAttributeList", "m_pManager");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CAttributeManager.g.cs

@@ -0,0 +1,41 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CAttributeManager : NativeObject
+{
+    public CAttributeManager (IntPtr pointer) : base(pointer) {}
+
+	// m_Providers
+	[SchemaMember("CAttributeManager", "m_Providers")]
+	public NetworkedVector<CHandle<CBaseEntity>> Providers => Schema.GetDeclaredClass<NetworkedVector<CHandle<CBaseEntity>>>(this.Handle, "CAttributeManager", "m_Providers");
+
+	// m_iReapplyProvisionParity
+	[SchemaMember("CAttributeManager", "m_iReapplyProvisionParity")]
+	public ref Int32 ReapplyProvisionParity => ref Schema.GetRef<Int32>(this.Handle, "CAttributeManager", "m_iReapplyProvisionParity");
+
+	// m_hOuter
+	[SchemaMember("CAttributeManager", "m_hOuter")]
+	public CHandle<CBaseEntity> Outer => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CAttributeManager", "m_hOuter");
+
+	// m_bPreventLoopback
+	[SchemaMember("CAttributeManager", "m_bPreventLoopback")]
+	public ref bool PreventLoopback => ref Schema.GetRef<bool>(this.Handle, "CAttributeManager", "m_bPreventLoopback");
+
+	// m_ProviderType
+	[SchemaMember("CAttributeManager", "m_ProviderType")]
+	public ref attributeprovidertypes_t ProviderType => ref Schema.GetRef<attributeprovidertypes_t>(this.Handle, "CAttributeManager", "m_ProviderType");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBarnLight.g.cs

@@ -0,0 +1,237 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBarnLight : CBaseModelEntity
+{
+    public CBarnLight (IntPtr pointer) : base(pointer) {}
+
+	// m_bEnabled
+	[SchemaMember("CBarnLight", "m_bEnabled")]
+	public ref bool Enabled => ref Schema.GetRef<bool>(this.Handle, "CBarnLight", "m_bEnabled");
+
+	// m_nColorMode
+	[SchemaMember("CBarnLight", "m_nColorMode")]
+	public ref Int32 ColorMode => ref Schema.GetRef<Int32>(this.Handle, "CBarnLight", "m_nColorMode");
+
+	// m_Color
+	[SchemaMember("CBarnLight", "m_Color")]
+	public Color Color
+	{
+		get { return Schema.GetCustomMarshalledType<Color>(this.Handle, "CBarnLight", "m_Color"); }
+		set { Schema.SetCustomMarshalledType<Color>(this.Handle, "CBarnLight", "m_Color", value); }
+	}
+
+	// m_flColorTemperature
+	[SchemaMember("CBarnLight", "m_flColorTemperature")]
+	public ref float ColorTemperature => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flColorTemperature");
+
+	// m_flBrightness
+	[SchemaMember("CBarnLight", "m_flBrightness")]
+	public ref float Brightness => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flBrightness");
+
+	// m_flBrightnessScale
+	[SchemaMember("CBarnLight", "m_flBrightnessScale")]
+	public ref float BrightnessScale => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flBrightnessScale");
+
+	// m_nDirectLight
+	[SchemaMember("CBarnLight", "m_nDirectLight")]
+	public ref Int32 DirectLight => ref Schema.GetRef<Int32>(this.Handle, "CBarnLight", "m_nDirectLight");
+
+	// m_nBakedShadowIndex
+	[SchemaMember("CBarnLight", "m_nBakedShadowIndex")]
+	public ref Int32 BakedShadowIndex => ref Schema.GetRef<Int32>(this.Handle, "CBarnLight", "m_nBakedShadowIndex");
+
+	// m_nLuminaireShape
+	[SchemaMember("CBarnLight", "m_nLuminaireShape")]
+	public ref Int32 LuminaireShape => ref Schema.GetRef<Int32>(this.Handle, "CBarnLight", "m_nLuminaireShape");
+
+	// m_flLuminaireSize
+	[SchemaMember("CBarnLight", "m_flLuminaireSize")]
+	public ref float LuminaireSize => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flLuminaireSize");
+
+	// m_flLuminaireAnisotropy
+	[SchemaMember("CBarnLight", "m_flLuminaireAnisotropy")]
+	public ref float LuminaireAnisotropy => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flLuminaireAnisotropy");
+
+	// m_LightStyleString
+	[SchemaMember("CBarnLight", "m_LightStyleString")]
+	public string LightStyleString
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBarnLight", "m_LightStyleString"); }
+		set { Schema.SetString(this.Handle, "CBarnLight", "m_LightStyleString", value); }
+	}
+
+	// m_flLightStyleStartTime
+	[SchemaMember("CBarnLight", "m_flLightStyleStartTime")]
+	public ref float LightStyleStartTime => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flLightStyleStartTime");
+
+	// m_QueuedLightStyleStrings
+	[SchemaMember("CBarnLight", "m_QueuedLightStyleStrings")]
+	public NetworkedVector<string> QueuedLightStyleStrings => Schema.GetDeclaredClass<NetworkedVector<string>>(this.Handle, "CBarnLight", "m_QueuedLightStyleStrings");
+
+	// m_LightStyleEvents
+	[SchemaMember("CBarnLight", "m_LightStyleEvents")]
+	public NetworkedVector<string> LightStyleEvents => Schema.GetDeclaredClass<NetworkedVector<string>>(this.Handle, "CBarnLight", "m_LightStyleEvents");
+
+	// m_LightStyleTargets
+	[SchemaMember("CBarnLight", "m_LightStyleTargets")]
+	public NetworkedVector<CHandle<CBaseModelEntity>> LightStyleTargets => Schema.GetDeclaredClass<NetworkedVector<CHandle<CBaseModelEntity>>>(this.Handle, "CBarnLight", "m_LightStyleTargets");
+
+	// m_StyleEvent
+	[SchemaMember("CBarnLight", "m_StyleEvent")]
+	public Span<CEntityIOOutput> StyleEvent => Schema.GetFixedArray<CEntityIOOutput>(this.Handle, "CBarnLight", "m_StyleEvent", 4);
+
+	// m_hLightCookie
+	[SchemaMember("CBarnLight", "m_hLightCookie")]
+	public CStrongHandle<InfoForResourceTypeCTextureBase> LightCookie => Schema.GetDeclaredClass<CStrongHandle<InfoForResourceTypeCTextureBase>>(this.Handle, "CBarnLight", "m_hLightCookie");
+
+	// m_flShape
+	[SchemaMember("CBarnLight", "m_flShape")]
+	public ref float Shape => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flShape");
+
+	// m_flSoftX
+	[SchemaMember("CBarnLight", "m_flSoftX")]
+	public ref float SoftX => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flSoftX");
+
+	// m_flSoftY
+	[SchemaMember("CBarnLight", "m_flSoftY")]
+	public ref float SoftY => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flSoftY");
+
+	// m_flSkirt
+	[SchemaMember("CBarnLight", "m_flSkirt")]
+	public ref float Skirt => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flSkirt");
+
+	// m_flSkirtNear
+	[SchemaMember("CBarnLight", "m_flSkirtNear")]
+	public ref float SkirtNear => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flSkirtNear");
+
+	// m_vSizeParams
+	[SchemaMember("CBarnLight", "m_vSizeParams")]
+	public Vector SizeParams => Schema.GetDeclaredClass<Vector>(this.Handle, "CBarnLight", "m_vSizeParams");
+
+	// m_flRange
+	[SchemaMember("CBarnLight", "m_flRange")]
+	public ref float Range => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flRange");
+
+	// m_vShear
+	[SchemaMember("CBarnLight", "m_vShear")]
+	public Vector Shear => Schema.GetDeclaredClass<Vector>(this.Handle, "CBarnLight", "m_vShear");
+
+	// m_nBakeSpecularToCubemaps
+	[SchemaMember("CBarnLight", "m_nBakeSpecularToCubemaps")]
+	public ref Int32 BakeSpecularToCubemaps => ref Schema.GetRef<Int32>(this.Handle, "CBarnLight", "m_nBakeSpecularToCubemaps");
+
+	// m_vBakeSpecularToCubemapsSize
+	[SchemaMember("CBarnLight", "m_vBakeSpecularToCubemapsSize")]
+	public Vector BakeSpecularToCubemapsSize => Schema.GetDeclaredClass<Vector>(this.Handle, "CBarnLight", "m_vBakeSpecularToCubemapsSize");
+
+	// m_nCastShadows
+	[SchemaMember("CBarnLight", "m_nCastShadows")]
+	public ref Int32 CastShadows => ref Schema.GetRef<Int32>(this.Handle, "CBarnLight", "m_nCastShadows");
+
+	// m_nShadowMapSize
+	[SchemaMember("CBarnLight", "m_nShadowMapSize")]
+	public ref Int32 ShadowMapSize => ref Schema.GetRef<Int32>(this.Handle, "CBarnLight", "m_nShadowMapSize");
+
+	// m_nShadowPriority
+	[SchemaMember("CBarnLight", "m_nShadowPriority")]
+	public ref Int32 ShadowPriority => ref Schema.GetRef<Int32>(this.Handle, "CBarnLight", "m_nShadowPriority");
+
+	// m_bContactShadow
+	[SchemaMember("CBarnLight", "m_bContactShadow")]
+	public ref bool ContactShadow => ref Schema.GetRef<bool>(this.Handle, "CBarnLight", "m_bContactShadow");
+
+	// m_nBounceLight
+	[SchemaMember("CBarnLight", "m_nBounceLight")]
+	public ref Int32 BounceLight => ref Schema.GetRef<Int32>(this.Handle, "CBarnLight", "m_nBounceLight");
+
+	// m_flBounceScale
+	[SchemaMember("CBarnLight", "m_flBounceScale")]
+	public ref float BounceScale => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flBounceScale");
+
+	// m_flMinRoughness
+	[SchemaMember("CBarnLight", "m_flMinRoughness")]
+	public ref float MinRoughness => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flMinRoughness");
+
+	// m_vAlternateColor
+	[SchemaMember("CBarnLight", "m_vAlternateColor")]
+	public Vector AlternateColor => Schema.GetDeclaredClass<Vector>(this.Handle, "CBarnLight", "m_vAlternateColor");
+
+	// m_fAlternateColorBrightness
+	[SchemaMember("CBarnLight", "m_fAlternateColorBrightness")]
+	public ref float AlternateColorBrightness => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_fAlternateColorBrightness");
+
+	// m_nFog
+	[SchemaMember("CBarnLight", "m_nFog")]
+	public ref Int32 Fog => ref Schema.GetRef<Int32>(this.Handle, "CBarnLight", "m_nFog");
+
+	// m_flFogStrength
+	[SchemaMember("CBarnLight", "m_flFogStrength")]
+	public ref float FogStrength => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flFogStrength");
+
+	// m_nFogShadows
+	[SchemaMember("CBarnLight", "m_nFogShadows")]
+	public ref Int32 FogShadows => ref Schema.GetRef<Int32>(this.Handle, "CBarnLight", "m_nFogShadows");
+
+	// m_flFogScale
+	[SchemaMember("CBarnLight", "m_flFogScale")]
+	public ref float FogScale => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flFogScale");
+
+	// m_flFadeSizeStart
+	[SchemaMember("CBarnLight", "m_flFadeSizeStart")]
+	public ref float FadeSizeStart => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flFadeSizeStart");
+
+	// m_flFadeSizeEnd
+	[SchemaMember("CBarnLight", "m_flFadeSizeEnd")]
+	public ref float FadeSizeEnd => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flFadeSizeEnd");
+
+	// m_flShadowFadeSizeStart
+	[SchemaMember("CBarnLight", "m_flShadowFadeSizeStart")]
+	public ref float ShadowFadeSizeStart => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flShadowFadeSizeStart");
+
+	// m_flShadowFadeSizeEnd
+	[SchemaMember("CBarnLight", "m_flShadowFadeSizeEnd")]
+	public ref float ShadowFadeSizeEnd => ref Schema.GetRef<float>(this.Handle, "CBarnLight", "m_flShadowFadeSizeEnd");
+
+	// m_bPrecomputedFieldsValid
+	[SchemaMember("CBarnLight", "m_bPrecomputedFieldsValid")]
+	public ref bool PrecomputedFieldsValid => ref Schema.GetRef<bool>(this.Handle, "CBarnLight", "m_bPrecomputedFieldsValid");
+
+	// m_vPrecomputedBoundsMins
+	[SchemaMember("CBarnLight", "m_vPrecomputedBoundsMins")]
+	public Vector PrecomputedBoundsMins => Schema.GetDeclaredClass<Vector>(this.Handle, "CBarnLight", "m_vPrecomputedBoundsMins");
+
+	// m_vPrecomputedBoundsMaxs
+	[SchemaMember("CBarnLight", "m_vPrecomputedBoundsMaxs")]
+	public Vector PrecomputedBoundsMaxs => Schema.GetDeclaredClass<Vector>(this.Handle, "CBarnLight", "m_vPrecomputedBoundsMaxs");
+
+	// m_vPrecomputedOBBOrigin
+	[SchemaMember("CBarnLight", "m_vPrecomputedOBBOrigin")]
+	public Vector PrecomputedOBBOrigin => Schema.GetDeclaredClass<Vector>(this.Handle, "CBarnLight", "m_vPrecomputedOBBOrigin");
+
+	// m_vPrecomputedOBBAngles
+	[SchemaMember("CBarnLight", "m_vPrecomputedOBBAngles")]
+	public QAngle PrecomputedOBBAngles => Schema.GetDeclaredClass<QAngle>(this.Handle, "CBarnLight", "m_vPrecomputedOBBAngles");
+
+	// m_vPrecomputedOBBExtent
+	[SchemaMember("CBarnLight", "m_vPrecomputedOBBExtent")]
+	public Vector PrecomputedOBBExtent => Schema.GetDeclaredClass<Vector>(this.Handle, "CBarnLight", "m_vPrecomputedOBBExtent");
+
+	// m_bPvsModifyEntity
+	[SchemaMember("CBarnLight", "m_bPvsModifyEntity")]
+	public ref bool PvsModifyEntity => ref Schema.GetRef<bool>(this.Handle, "CBarnLight", "m_bPvsModifyEntity");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseAnimGraph.g.cs

@@ -0,0 +1,61 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseAnimGraph : CBaseModelEntity
+{
+    public CBaseAnimGraph (IntPtr pointer) : base(pointer) {}
+
+	// m_bInitiallyPopulateInterpHistory
+	[SchemaMember("CBaseAnimGraph", "m_bInitiallyPopulateInterpHistory")]
+	public ref bool InitiallyPopulateInterpHistory => ref Schema.GetRef<bool>(this.Handle, "CBaseAnimGraph", "m_bInitiallyPopulateInterpHistory");
+
+	// m_pChoreoServices
+	[SchemaMember("CBaseAnimGraph", "m_pChoreoServices")]
+	public IChoreoServices? ChoreoServices => Schema.GetPointer<IChoreoServices>(this.Handle, "CBaseAnimGraph", "m_pChoreoServices");
+
+	// m_bAnimGraphUpdateEnabled
+	[SchemaMember("CBaseAnimGraph", "m_bAnimGraphUpdateEnabled")]
+	public ref bool AnimGraphUpdateEnabled => ref Schema.GetRef<bool>(this.Handle, "CBaseAnimGraph", "m_bAnimGraphUpdateEnabled");
+
+	// m_flMaxSlopeDistance
+	[SchemaMember("CBaseAnimGraph", "m_flMaxSlopeDistance")]
+	public ref float MaxSlopeDistance => ref Schema.GetRef<float>(this.Handle, "CBaseAnimGraph", "m_flMaxSlopeDistance");
+
+	// m_vLastSlopeCheckPos
+	[SchemaMember("CBaseAnimGraph", "m_vLastSlopeCheckPos")]
+	public Vector LastSlopeCheckPos => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseAnimGraph", "m_vLastSlopeCheckPos");
+
+	// m_bAnimationUpdateScheduled
+	[SchemaMember("CBaseAnimGraph", "m_bAnimationUpdateScheduled")]
+	public ref bool AnimationUpdateScheduled => ref Schema.GetRef<bool>(this.Handle, "CBaseAnimGraph", "m_bAnimationUpdateScheduled");
+
+	// m_vecForce
+	[SchemaMember("CBaseAnimGraph", "m_vecForce")]
+	public Vector Force => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseAnimGraph", "m_vecForce");
+
+	// m_nForceBone
+	[SchemaMember("CBaseAnimGraph", "m_nForceBone")]
+	public ref Int32 ForceBone => ref Schema.GetRef<Int32>(this.Handle, "CBaseAnimGraph", "m_nForceBone");
+
+	// m_pRagdollPose
+	[SchemaMember("CBaseAnimGraph", "m_pRagdollPose")]
+	public PhysicsRagdollPose_t? RagdollPose => Schema.GetPointer<PhysicsRagdollPose_t>(this.Handle, "CBaseAnimGraph", "m_pRagdollPose");
+
+	// m_bClientRagdoll
+	[SchemaMember("CBaseAnimGraph", "m_bClientRagdoll")]
+	public ref bool ClientRagdoll => ref Schema.GetRef<bool>(this.Handle, "CBaseAnimGraph", "m_bClientRagdoll");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseAnimGraphController.g.cs

@@ -0,0 +1,73 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseAnimGraphController : CSkeletonAnimationController
+{
+    public CBaseAnimGraphController (IntPtr pointer) : base(pointer) {}
+
+	// m_animGraphNetworkedVars
+	[SchemaMember("CBaseAnimGraphController", "m_animGraphNetworkedVars")]
+	public CAnimGraphNetworkedVariables AnimGraphNetworkedVars => Schema.GetDeclaredClass<CAnimGraphNetworkedVariables>(this.Handle, "CBaseAnimGraphController", "m_animGraphNetworkedVars");
+
+	// m_bSequenceFinished
+	[SchemaMember("CBaseAnimGraphController", "m_bSequenceFinished")]
+	public ref bool SequenceFinished => ref Schema.GetRef<bool>(this.Handle, "CBaseAnimGraphController", "m_bSequenceFinished");
+
+	// m_flSoundSyncTime
+	[SchemaMember("CBaseAnimGraphController", "m_flSoundSyncTime")]
+	public ref float SoundSyncTime => ref Schema.GetRef<float>(this.Handle, "CBaseAnimGraphController", "m_flSoundSyncTime");
+
+	// m_hSequence
+	[SchemaMember("CBaseAnimGraphController", "m_hSequence")]
+	public ref Int32 Sequence => ref Schema.GetRef<Int32>(this.Handle, "CBaseAnimGraphController", "m_hSequence");
+
+	// m_flSeqStartTime
+	[SchemaMember("CBaseAnimGraphController", "m_flSeqStartTime")]
+	public ref float SeqStartTime => ref Schema.GetRef<float>(this.Handle, "CBaseAnimGraphController", "m_flSeqStartTime");
+
+	// m_flSeqFixedCycle
+	[SchemaMember("CBaseAnimGraphController", "m_flSeqFixedCycle")]
+	public ref float SeqFixedCycle => ref Schema.GetRef<float>(this.Handle, "CBaseAnimGraphController", "m_flSeqFixedCycle");
+
+	// m_nAnimLoopMode
+	[SchemaMember("CBaseAnimGraphController", "m_nAnimLoopMode")]
+	public ref AnimLoopMode_t AnimLoopMode => ref Schema.GetRef<AnimLoopMode_t>(this.Handle, "CBaseAnimGraphController", "m_nAnimLoopMode");
+
+	// m_flPlaybackRate
+	[SchemaMember("CBaseAnimGraphController", "m_flPlaybackRate")]
+	public float PlaybackRate => Schema.GetDeclaredClass<float>(this.Handle, "CBaseAnimGraphController", "m_flPlaybackRate");
+
+	// m_nNotifyState
+	[SchemaMember("CBaseAnimGraphController", "m_nNotifyState")]
+	public ref SequenceFinishNotifyState_t NotifyState => ref Schema.GetRef<SequenceFinishNotifyState_t>(this.Handle, "CBaseAnimGraphController", "m_nNotifyState");
+
+	// m_bNetworkedAnimationInputsChanged
+	[SchemaMember("CBaseAnimGraphController", "m_bNetworkedAnimationInputsChanged")]
+	public ref bool NetworkedAnimationInputsChanged => ref Schema.GetRef<bool>(this.Handle, "CBaseAnimGraphController", "m_bNetworkedAnimationInputsChanged");
+
+	// m_bNetworkedSequenceChanged
+	[SchemaMember("CBaseAnimGraphController", "m_bNetworkedSequenceChanged")]
+	public ref bool NetworkedSequenceChanged => ref Schema.GetRef<bool>(this.Handle, "CBaseAnimGraphController", "m_bNetworkedSequenceChanged");
+
+	// m_bLastUpdateSkipped
+	[SchemaMember("CBaseAnimGraphController", "m_bLastUpdateSkipped")]
+	public ref bool LastUpdateSkipped => ref Schema.GetRef<bool>(this.Handle, "CBaseAnimGraphController", "m_bLastUpdateSkipped");
+
+	// m_flPrevAnimUpdateTime
+	[SchemaMember("CBaseAnimGraphController", "m_flPrevAnimUpdateTime")]
+	public ref float PrevAnimUpdateTime => ref Schema.GetRef<float>(this.Handle, "CBaseAnimGraphController", "m_flPrevAnimUpdateTime");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseButton.g.cs

@@ -0,0 +1,137 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseButton : CBaseToggle
+{
+    public CBaseButton (IntPtr pointer) : base(pointer) {}
+
+	// m_angMoveEntitySpace
+	[SchemaMember("CBaseButton", "m_angMoveEntitySpace")]
+	public QAngle MoveEntitySpace => Schema.GetDeclaredClass<QAngle>(this.Handle, "CBaseButton", "m_angMoveEntitySpace");
+
+	// m_fStayPushed
+	[SchemaMember("CBaseButton", "m_fStayPushed")]
+	public ref bool StayPushed => ref Schema.GetRef<bool>(this.Handle, "CBaseButton", "m_fStayPushed");
+
+	// m_fRotating
+	[SchemaMember("CBaseButton", "m_fRotating")]
+	public ref bool Rotating => ref Schema.GetRef<bool>(this.Handle, "CBaseButton", "m_fRotating");
+
+	// m_ls
+	[SchemaMember("CBaseButton", "m_ls")]
+	public locksound_t Ls => Schema.GetDeclaredClass<locksound_t>(this.Handle, "CBaseButton", "m_ls");
+
+	// m_sUseSound
+	[SchemaMember("CBaseButton", "m_sUseSound")]
+	public string UseSound
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseButton", "m_sUseSound"); }
+		set { Schema.SetString(this.Handle, "CBaseButton", "m_sUseSound", value); }
+	}
+
+	// m_sLockedSound
+	[SchemaMember("CBaseButton", "m_sLockedSound")]
+	public string LockedSound
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseButton", "m_sLockedSound"); }
+		set { Schema.SetString(this.Handle, "CBaseButton", "m_sLockedSound", value); }
+	}
+
+	// m_sUnlockedSound
+	[SchemaMember("CBaseButton", "m_sUnlockedSound")]
+	public string UnlockedSound
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseButton", "m_sUnlockedSound"); }
+		set { Schema.SetString(this.Handle, "CBaseButton", "m_sUnlockedSound", value); }
+	}
+
+	// m_bLocked
+	[SchemaMember("CBaseButton", "m_bLocked")]
+	public ref bool Locked => ref Schema.GetRef<bool>(this.Handle, "CBaseButton", "m_bLocked");
+
+	// m_bDisabled
+	[SchemaMember("CBaseButton", "m_bDisabled")]
+	public ref bool Disabled => ref Schema.GetRef<bool>(this.Handle, "CBaseButton", "m_bDisabled");
+
+	// m_flUseLockedTime
+	[SchemaMember("CBaseButton", "m_flUseLockedTime")]
+	public ref float UseLockedTime => ref Schema.GetRef<float>(this.Handle, "CBaseButton", "m_flUseLockedTime");
+
+	// m_bSolidBsp
+	[SchemaMember("CBaseButton", "m_bSolidBsp")]
+	public ref bool SolidBsp => ref Schema.GetRef<bool>(this.Handle, "CBaseButton", "m_bSolidBsp");
+
+	// m_OnDamaged
+	[SchemaMember("CBaseButton", "m_OnDamaged")]
+	public CEntityIOOutput OnDamaged => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseButton", "m_OnDamaged");
+
+	// m_OnPressed
+	[SchemaMember("CBaseButton", "m_OnPressed")]
+	public CEntityIOOutput OnPressed => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseButton", "m_OnPressed");
+
+	// m_OnUseLocked
+	[SchemaMember("CBaseButton", "m_OnUseLocked")]
+	public CEntityIOOutput OnUseLocked => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseButton", "m_OnUseLocked");
+
+	// m_OnIn
+	[SchemaMember("CBaseButton", "m_OnIn")]
+	public CEntityIOOutput OnIn => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseButton", "m_OnIn");
+
+	// m_OnOut
+	[SchemaMember("CBaseButton", "m_OnOut")]
+	public CEntityIOOutput OnOut => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseButton", "m_OnOut");
+
+	// m_nState
+	[SchemaMember("CBaseButton", "m_nState")]
+	public ref Int32 State => ref Schema.GetRef<Int32>(this.Handle, "CBaseButton", "m_nState");
+
+	// m_hConstraint
+	[SchemaMember("CBaseButton", "m_hConstraint")]
+	public CHandle<CEntityInstance> Constraint => Schema.GetDeclaredClass<CHandle<CEntityInstance>>(this.Handle, "CBaseButton", "m_hConstraint");
+
+	// m_hConstraintParent
+	[SchemaMember("CBaseButton", "m_hConstraintParent")]
+	public CHandle<CEntityInstance> ConstraintParent => Schema.GetDeclaredClass<CHandle<CEntityInstance>>(this.Handle, "CBaseButton", "m_hConstraintParent");
+
+	// m_bForceNpcExclude
+	[SchemaMember("CBaseButton", "m_bForceNpcExclude")]
+	public ref bool ForceNpcExclude => ref Schema.GetRef<bool>(this.Handle, "CBaseButton", "m_bForceNpcExclude");
+
+	// m_sGlowEntity
+	[SchemaMember("CBaseButton", "m_sGlowEntity")]
+	public string SGlowEntity
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseButton", "m_sGlowEntity"); }
+		set { Schema.SetString(this.Handle, "CBaseButton", "m_sGlowEntity", value); }
+	}
+
+	// m_glowEntity
+	[SchemaMember("CBaseButton", "m_glowEntity")]
+	public CHandle<CBaseModelEntity> GlowEntity => Schema.GetDeclaredClass<CHandle<CBaseModelEntity>>(this.Handle, "CBaseButton", "m_glowEntity");
+
+	// m_usable
+	[SchemaMember("CBaseButton", "m_usable")]
+	public ref bool Usable => ref Schema.GetRef<bool>(this.Handle, "CBaseButton", "m_usable");
+
+	// m_szDisplayText
+	[SchemaMember("CBaseButton", "m_szDisplayText")]
+	public string DisplayText
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseButton", "m_szDisplayText"); }
+		set { Schema.SetString(this.Handle, "CBaseButton", "m_szDisplayText", value); }
+	}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseCSGrenade.g.cs

@@ -0,0 +1,73 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseCSGrenade : CCSWeaponBase
+{
+    public CBaseCSGrenade (IntPtr pointer) : base(pointer) {}
+
+	// m_bRedraw
+	[SchemaMember("CBaseCSGrenade", "m_bRedraw")]
+	public ref bool Redraw => ref Schema.GetRef<bool>(this.Handle, "CBaseCSGrenade", "m_bRedraw");
+
+	// m_bIsHeldByPlayer
+	[SchemaMember("CBaseCSGrenade", "m_bIsHeldByPlayer")]
+	public ref bool IsHeldByPlayer => ref Schema.GetRef<bool>(this.Handle, "CBaseCSGrenade", "m_bIsHeldByPlayer");
+
+	// m_bPinPulled
+	[SchemaMember("CBaseCSGrenade", "m_bPinPulled")]
+	public ref bool PinPulled => ref Schema.GetRef<bool>(this.Handle, "CBaseCSGrenade", "m_bPinPulled");
+
+	// m_bJumpThrow
+	[SchemaMember("CBaseCSGrenade", "m_bJumpThrow")]
+	public ref bool JumpThrow => ref Schema.GetRef<bool>(this.Handle, "CBaseCSGrenade", "m_bJumpThrow");
+
+	// m_bThrowAnimating
+	[SchemaMember("CBaseCSGrenade", "m_bThrowAnimating")]
+	public ref bool ThrowAnimating => ref Schema.GetRef<bool>(this.Handle, "CBaseCSGrenade", "m_bThrowAnimating");
+
+	// m_fThrowTime
+	[SchemaMember("CBaseCSGrenade", "m_fThrowTime")]
+	public ref float ThrowTime => ref Schema.GetRef<float>(this.Handle, "CBaseCSGrenade", "m_fThrowTime");
+
+	// m_flThrowStrength
+	[SchemaMember("CBaseCSGrenade", "m_flThrowStrength")]
+	public ref float ThrowStrength => ref Schema.GetRef<float>(this.Handle, "CBaseCSGrenade", "m_flThrowStrength");
+
+	// m_flThrowStrengthApproach
+	[SchemaMember("CBaseCSGrenade", "m_flThrowStrengthApproach")]
+	public ref float ThrowStrengthApproach => ref Schema.GetRef<float>(this.Handle, "CBaseCSGrenade", "m_flThrowStrengthApproach");
+
+	// m_fDropTime
+	[SchemaMember("CBaseCSGrenade", "m_fDropTime")]
+	public ref float DropTime => ref Schema.GetRef<float>(this.Handle, "CBaseCSGrenade", "m_fDropTime");
+
+	// m_bJustPulledPin
+	[SchemaMember("CBaseCSGrenade", "m_bJustPulledPin")]
+	public ref bool JustPulledPin => ref Schema.GetRef<bool>(this.Handle, "CBaseCSGrenade", "m_bJustPulledPin");
+
+	// m_nNextHoldTick
+	[SchemaMember("CBaseCSGrenade", "m_nNextHoldTick")]
+	public ref Int32 NextHoldTick => ref Schema.GetRef<Int32>(this.Handle, "CBaseCSGrenade", "m_nNextHoldTick");
+
+	// m_flNextHoldFrac
+	[SchemaMember("CBaseCSGrenade", "m_flNextHoldFrac")]
+	public ref float NextHoldFrac => ref Schema.GetRef<float>(this.Handle, "CBaseCSGrenade", "m_flNextHoldFrac");
+
+	// m_hSwitchToWeaponAfterThrow
+	[SchemaMember("CBaseCSGrenade", "m_hSwitchToWeaponAfterThrow")]
+	public CHandle<CCSWeaponBase> SwitchToWeaponAfterThrow => Schema.GetDeclaredClass<CHandle<CCSWeaponBase>>(this.Handle, "CBaseCSGrenade", "m_hSwitchToWeaponAfterThrow");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseCSGrenadeProjectile.g.cs

@@ -0,0 +1,93 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseCSGrenadeProjectile : CBaseGrenade
+{
+    public CBaseCSGrenadeProjectile (IntPtr pointer) : base(pointer) {}
+
+	// m_vInitialPosition
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_vInitialPosition")]
+	public Vector InitialPosition => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseCSGrenadeProjectile", "m_vInitialPosition");
+
+	// m_vInitialVelocity
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_vInitialVelocity")]
+	public Vector InitialVelocity => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseCSGrenadeProjectile", "m_vInitialVelocity");
+
+	// m_nBounces
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_nBounces")]
+	public ref Int32 Bounces => ref Schema.GetRef<Int32>(this.Handle, "CBaseCSGrenadeProjectile", "m_nBounces");
+
+	// m_nExplodeEffectIndex
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_nExplodeEffectIndex")]
+	public CStrongHandle<InfoForResourceTypeIParticleSystemDefinition> ExplodeEffectIndex => Schema.GetDeclaredClass<CStrongHandle<InfoForResourceTypeIParticleSystemDefinition>>(this.Handle, "CBaseCSGrenadeProjectile", "m_nExplodeEffectIndex");
+
+	// m_nExplodeEffectTickBegin
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_nExplodeEffectTickBegin")]
+	public ref Int32 ExplodeEffectTickBegin => ref Schema.GetRef<Int32>(this.Handle, "CBaseCSGrenadeProjectile", "m_nExplodeEffectTickBegin");
+
+	// m_vecExplodeEffectOrigin
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_vecExplodeEffectOrigin")]
+	public Vector ExplodeEffectOrigin => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseCSGrenadeProjectile", "m_vecExplodeEffectOrigin");
+
+	// m_flSpawnTime
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_flSpawnTime")]
+	public ref float SpawnTime => ref Schema.GetRef<float>(this.Handle, "CBaseCSGrenadeProjectile", "m_flSpawnTime");
+
+	// m_unOGSExtraFlags
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_unOGSExtraFlags")]
+	public ref byte OGSExtraFlags => ref Schema.GetRef<byte>(this.Handle, "CBaseCSGrenadeProjectile", "m_unOGSExtraFlags");
+
+	// m_bDetonationRecorded
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_bDetonationRecorded")]
+	public ref bool DetonationRecorded => ref Schema.GetRef<bool>(this.Handle, "CBaseCSGrenadeProjectile", "m_bDetonationRecorded");
+
+	// m_flDetonateTime
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_flDetonateTime")]
+	public ref float DetonateTime => ref Schema.GetRef<float>(this.Handle, "CBaseCSGrenadeProjectile", "m_flDetonateTime");
+
+	// m_nItemIndex
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_nItemIndex")]
+	public ref UInt16 ItemIndex => ref Schema.GetRef<UInt16>(this.Handle, "CBaseCSGrenadeProjectile", "m_nItemIndex");
+
+	// m_vecOriginalSpawnLocation
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_vecOriginalSpawnLocation")]
+	public Vector OriginalSpawnLocation => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseCSGrenadeProjectile", "m_vecOriginalSpawnLocation");
+
+	// m_flLastBounceSoundTime
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_flLastBounceSoundTime")]
+	public ref float LastBounceSoundTime => ref Schema.GetRef<float>(this.Handle, "CBaseCSGrenadeProjectile", "m_flLastBounceSoundTime");
+
+	// m_vecGrenadeSpin
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_vecGrenadeSpin")]
+	public Vector GrenadeSpin => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseCSGrenadeProjectile", "m_vecGrenadeSpin");
+
+	// m_vecLastHitSurfaceNormal
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_vecLastHitSurfaceNormal")]
+	public Vector LastHitSurfaceNormal => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseCSGrenadeProjectile", "m_vecLastHitSurfaceNormal");
+
+	// m_nTicksAtZeroVelocity
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_nTicksAtZeroVelocity")]
+	public ref Int32 TicksAtZeroVelocity => ref Schema.GetRef<Int32>(this.Handle, "CBaseCSGrenadeProjectile", "m_nTicksAtZeroVelocity");
+
+	// m_bHasEverHitPlayer
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_bHasEverHitPlayer")]
+	public ref bool HasEverHitPlayer => ref Schema.GetRef<bool>(this.Handle, "CBaseCSGrenadeProjectile", "m_bHasEverHitPlayer");
+
+	// m_bClearFromPlayers
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_bClearFromPlayers")]
+	public ref bool ClearFromPlayers => ref Schema.GetRef<bool>(this.Handle, "CBaseCSGrenadeProjectile", "m_bClearFromPlayers");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseClientUIEntity.g.cs

@@ -0,0 +1,89 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseClientUIEntity : CBaseModelEntity
+{
+    public CBaseClientUIEntity (IntPtr pointer) : base(pointer) {}
+
+	// m_bEnabled
+	[SchemaMember("CBaseClientUIEntity", "m_bEnabled")]
+	public ref bool Enabled => ref Schema.GetRef<bool>(this.Handle, "CBaseClientUIEntity", "m_bEnabled");
+
+	// m_DialogXMLName
+	[SchemaMember("CBaseClientUIEntity", "m_DialogXMLName")]
+	public string DialogXMLName
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseClientUIEntity", "m_DialogXMLName"); }
+		set { Schema.SetString(this.Handle, "CBaseClientUIEntity", "m_DialogXMLName", value); }
+	}
+
+	// m_PanelClassName
+	[SchemaMember("CBaseClientUIEntity", "m_PanelClassName")]
+	public string PanelClassName
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseClientUIEntity", "m_PanelClassName"); }
+		set { Schema.SetString(this.Handle, "CBaseClientUIEntity", "m_PanelClassName", value); }
+	}
+
+	// m_PanelID
+	[SchemaMember("CBaseClientUIEntity", "m_PanelID")]
+	public string PanelID
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseClientUIEntity", "m_PanelID"); }
+		set { Schema.SetString(this.Handle, "CBaseClientUIEntity", "m_PanelID", value); }
+	}
+
+	// m_CustomOutput0
+	[SchemaMember("CBaseClientUIEntity", "m_CustomOutput0")]
+	public CEntityIOOutput CustomOutput0 => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseClientUIEntity", "m_CustomOutput0");
+
+	// m_CustomOutput1
+	[SchemaMember("CBaseClientUIEntity", "m_CustomOutput1")]
+	public CEntityIOOutput CustomOutput1 => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseClientUIEntity", "m_CustomOutput1");
+
+	// m_CustomOutput2
+	[SchemaMember("CBaseClientUIEntity", "m_CustomOutput2")]
+	public CEntityIOOutput CustomOutput2 => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseClientUIEntity", "m_CustomOutput2");
+
+	// m_CustomOutput3
+	[SchemaMember("CBaseClientUIEntity", "m_CustomOutput3")]
+	public CEntityIOOutput CustomOutput3 => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseClientUIEntity", "m_CustomOutput3");
+
+	// m_CustomOutput4
+	[SchemaMember("CBaseClientUIEntity", "m_CustomOutput4")]
+	public CEntityIOOutput CustomOutput4 => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseClientUIEntity", "m_CustomOutput4");
+
+	// m_CustomOutput5
+	[SchemaMember("CBaseClientUIEntity", "m_CustomOutput5")]
+	public CEntityIOOutput CustomOutput5 => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseClientUIEntity", "m_CustomOutput5");
+
+	// m_CustomOutput6
+	[SchemaMember("CBaseClientUIEntity", "m_CustomOutput6")]
+	public CEntityIOOutput CustomOutput6 => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseClientUIEntity", "m_CustomOutput6");
+
+	// m_CustomOutput7
+	[SchemaMember("CBaseClientUIEntity", "m_CustomOutput7")]
+	public CEntityIOOutput CustomOutput7 => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseClientUIEntity", "m_CustomOutput7");
+
+	// m_CustomOutput8
+	[SchemaMember("CBaseClientUIEntity", "m_CustomOutput8")]
+	public CEntityIOOutput CustomOutput8 => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseClientUIEntity", "m_CustomOutput8");
+
+	// m_CustomOutput9
+	[SchemaMember("CBaseClientUIEntity", "m_CustomOutput9")]
+	public CEntityIOOutput CustomOutput9 => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseClientUIEntity", "m_CustomOutput9");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseCombatCharacter.g.cs

@@ -0,0 +1,69 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseCombatCharacter : CBaseFlex
+{
+    public CBaseCombatCharacter (IntPtr pointer) : base(pointer) {}
+
+	// m_bForceServerRagdoll
+	[SchemaMember("CBaseCombatCharacter", "m_bForceServerRagdoll")]
+	public ref bool ForceServerRagdoll => ref Schema.GetRef<bool>(this.Handle, "CBaseCombatCharacter", "m_bForceServerRagdoll");
+
+	// m_hMyWearables
+	[SchemaMember("CBaseCombatCharacter", "m_hMyWearables")]
+	public NetworkedVector<CHandle<CEconWearable>> MyWearables => Schema.GetDeclaredClass<NetworkedVector<CHandle<CEconWearable>>>(this.Handle, "CBaseCombatCharacter", "m_hMyWearables");
+
+	// m_flFieldOfView
+	[SchemaMember("CBaseCombatCharacter", "m_flFieldOfView")]
+	public ref float FieldOfView => ref Schema.GetRef<float>(this.Handle, "CBaseCombatCharacter", "m_flFieldOfView");
+
+	// m_impactEnergyScale
+	[SchemaMember("CBaseCombatCharacter", "m_impactEnergyScale")]
+	public ref float ImpactEnergyScale => ref Schema.GetRef<float>(this.Handle, "CBaseCombatCharacter", "m_impactEnergyScale");
+
+	// m_LastHitGroup
+	[SchemaMember("CBaseCombatCharacter", "m_LastHitGroup")]
+	public ref HitGroup_t LastHitGroup => ref Schema.GetRef<HitGroup_t>(this.Handle, "CBaseCombatCharacter", "m_LastHitGroup");
+
+	// m_bApplyStressDamage
+	[SchemaMember("CBaseCombatCharacter", "m_bApplyStressDamage")]
+	public ref bool ApplyStressDamage => ref Schema.GetRef<bool>(this.Handle, "CBaseCombatCharacter", "m_bApplyStressDamage");
+
+	// m_bloodColor
+	[SchemaMember("CBaseCombatCharacter", "m_bloodColor")]
+	public ref Int32 BloodColor => ref Schema.GetRef<Int32>(this.Handle, "CBaseCombatCharacter", "m_bloodColor");
+
+	// m_iDamageCount
+	[SchemaMember("CBaseCombatCharacter", "m_iDamageCount")]
+	public ref Int32 DamageCount => ref Schema.GetRef<Int32>(this.Handle, "CBaseCombatCharacter", "m_iDamageCount");
+
+	// m_strRelationships
+	[SchemaMember("CBaseCombatCharacter", "m_strRelationships")]
+	public string StrRelationships
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseCombatCharacter", "m_strRelationships"); }
+		set { Schema.SetString(this.Handle, "CBaseCombatCharacter", "m_strRelationships", value); }
+	}
+
+	// m_eHull
+	[SchemaMember("CBaseCombatCharacter", "m_eHull")]
+	public ref Hull_t Hull => ref Schema.GetRef<Hull_t>(this.Handle, "CBaseCombatCharacter", "m_eHull");
+
+	// m_nNavHullIdx
+	[SchemaMember("CBaseCombatCharacter", "m_nNavHullIdx")]
+	public ref UInt32 NavHullIdx => ref Schema.GetRef<UInt32>(this.Handle, "CBaseCombatCharacter", "m_nNavHullIdx");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseDMStart.g.cs

@@ -0,0 +1,29 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseDMStart : CPointEntity
+{
+    public CBaseDMStart (IntPtr pointer) : base(pointer) {}
+
+	// m_Master
+	[SchemaMember("CBaseDMStart", "m_Master")]
+	public string Master
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseDMStart", "m_Master"); }
+		set { Schema.SetString(this.Handle, "CBaseDMStart", "m_Master", value); }
+	}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseDoor.g.cs

@@ -0,0 +1,149 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseDoor : CBaseToggle
+{
+    public CBaseDoor (IntPtr pointer) : base(pointer) {}
+
+	// m_angMoveEntitySpace
+	[SchemaMember("CBaseDoor", "m_angMoveEntitySpace")]
+	public QAngle MoveEntitySpace => Schema.GetDeclaredClass<QAngle>(this.Handle, "CBaseDoor", "m_angMoveEntitySpace");
+
+	// m_vecMoveDirParentSpace
+	[SchemaMember("CBaseDoor", "m_vecMoveDirParentSpace")]
+	public Vector MoveDirParentSpace => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseDoor", "m_vecMoveDirParentSpace");
+
+	// m_ls
+	[SchemaMember("CBaseDoor", "m_ls")]
+	public locksound_t Ls => Schema.GetDeclaredClass<locksound_t>(this.Handle, "CBaseDoor", "m_ls");
+
+	// m_bForceClosed
+	[SchemaMember("CBaseDoor", "m_bForceClosed")]
+	public ref bool ForceClosed => ref Schema.GetRef<bool>(this.Handle, "CBaseDoor", "m_bForceClosed");
+
+	// m_bDoorGroup
+	[SchemaMember("CBaseDoor", "m_bDoorGroup")]
+	public ref bool DoorGroup => ref Schema.GetRef<bool>(this.Handle, "CBaseDoor", "m_bDoorGroup");
+
+	// m_bLocked
+	[SchemaMember("CBaseDoor", "m_bLocked")]
+	public ref bool Locked => ref Schema.GetRef<bool>(this.Handle, "CBaseDoor", "m_bLocked");
+
+	// m_bIgnoreDebris
+	[SchemaMember("CBaseDoor", "m_bIgnoreDebris")]
+	public ref bool IgnoreDebris => ref Schema.GetRef<bool>(this.Handle, "CBaseDoor", "m_bIgnoreDebris");
+
+	// m_eSpawnPosition
+	[SchemaMember("CBaseDoor", "m_eSpawnPosition")]
+	public ref FuncDoorSpawnPos_t SpawnPosition => ref Schema.GetRef<FuncDoorSpawnPos_t>(this.Handle, "CBaseDoor", "m_eSpawnPosition");
+
+	// m_flBlockDamage
+	[SchemaMember("CBaseDoor", "m_flBlockDamage")]
+	public ref float BlockDamage => ref Schema.GetRef<float>(this.Handle, "CBaseDoor", "m_flBlockDamage");
+
+	// m_NoiseMoving
+	[SchemaMember("CBaseDoor", "m_NoiseMoving")]
+	public string NoiseMoving
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseDoor", "m_NoiseMoving"); }
+		set { Schema.SetString(this.Handle, "CBaseDoor", "m_NoiseMoving", value); }
+	}
+
+	// m_NoiseArrived
+	[SchemaMember("CBaseDoor", "m_NoiseArrived")]
+	public string NoiseArrived
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseDoor", "m_NoiseArrived"); }
+		set { Schema.SetString(this.Handle, "CBaseDoor", "m_NoiseArrived", value); }
+	}
+
+	// m_NoiseMovingClosed
+	[SchemaMember("CBaseDoor", "m_NoiseMovingClosed")]
+	public string NoiseMovingClosed
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseDoor", "m_NoiseMovingClosed"); }
+		set { Schema.SetString(this.Handle, "CBaseDoor", "m_NoiseMovingClosed", value); }
+	}
+
+	// m_NoiseArrivedClosed
+	[SchemaMember("CBaseDoor", "m_NoiseArrivedClosed")]
+	public string NoiseArrivedClosed
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseDoor", "m_NoiseArrivedClosed"); }
+		set { Schema.SetString(this.Handle, "CBaseDoor", "m_NoiseArrivedClosed", value); }
+	}
+
+	// m_ChainTarget
+	[SchemaMember("CBaseDoor", "m_ChainTarget")]
+	public string ChainTarget
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseDoor", "m_ChainTarget"); }
+		set { Schema.SetString(this.Handle, "CBaseDoor", "m_ChainTarget", value); }
+	}
+
+	// m_OnBlockedClosing
+	[SchemaMember("CBaseDoor", "m_OnBlockedClosing")]
+	public CEntityIOOutput OnBlockedClosing => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseDoor", "m_OnBlockedClosing");
+
+	// m_OnBlockedOpening
+	[SchemaMember("CBaseDoor", "m_OnBlockedOpening")]
+	public CEntityIOOutput OnBlockedOpening => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseDoor", "m_OnBlockedOpening");
+
+	// m_OnUnblockedClosing
+	[SchemaMember("CBaseDoor", "m_OnUnblockedClosing")]
+	public CEntityIOOutput OnUnblockedClosing => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseDoor", "m_OnUnblockedClosing");
+
+	// m_OnUnblockedOpening
+	[SchemaMember("CBaseDoor", "m_OnUnblockedOpening")]
+	public CEntityIOOutput OnUnblockedOpening => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseDoor", "m_OnUnblockedOpening");
+
+	// m_OnFullyClosed
+	[SchemaMember("CBaseDoor", "m_OnFullyClosed")]
+	public CEntityIOOutput OnFullyClosed => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseDoor", "m_OnFullyClosed");
+
+	// m_OnFullyOpen
+	[SchemaMember("CBaseDoor", "m_OnFullyOpen")]
+	public CEntityIOOutput OnFullyOpen => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseDoor", "m_OnFullyOpen");
+
+	// m_OnClose
+	[SchemaMember("CBaseDoor", "m_OnClose")]
+	public CEntityIOOutput OnClose => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseDoor", "m_OnClose");
+
+	// m_OnOpen
+	[SchemaMember("CBaseDoor", "m_OnOpen")]
+	public CEntityIOOutput OnOpen => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseDoor", "m_OnOpen");
+
+	// m_OnLockedUse
+	[SchemaMember("CBaseDoor", "m_OnLockedUse")]
+	public CEntityIOOutput OnLockedUse => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseDoor", "m_OnLockedUse");
+
+	// m_bLoopMoveSound
+	[SchemaMember("CBaseDoor", "m_bLoopMoveSound")]
+	public ref bool LoopMoveSound => ref Schema.GetRef<bool>(this.Handle, "CBaseDoor", "m_bLoopMoveSound");
+
+	// m_bCreateNavObstacle
+	[SchemaMember("CBaseDoor", "m_bCreateNavObstacle")]
+	public ref bool CreateNavObstacle => ref Schema.GetRef<bool>(this.Handle, "CBaseDoor", "m_bCreateNavObstacle");
+
+	// m_isChaining
+	[SchemaMember("CBaseDoor", "m_isChaining")]
+	public ref bool IsChaining => ref Schema.GetRef<bool>(this.Handle, "CBaseDoor", "m_isChaining");
+
+	// m_bIsUsable
+	[SchemaMember("CBaseDoor", "m_bIsUsable")]
+	public ref bool IsUsable => ref Schema.GetRef<bool>(this.Handle, "CBaseDoor", "m_bIsUsable");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseEntity.g.cs

@@ -0,0 +1,341 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseEntity : CEntityInstance
+{
+    public CBaseEntity (IntPtr pointer) : base(pointer) {}
+
+	// m_CBodyComponent
+	[SchemaMember("CBaseEntity", "m_CBodyComponent")]
+	public CBodyComponent? CBodyComponent => Schema.GetPointer<CBodyComponent>(this.Handle, "CBaseEntity", "m_CBodyComponent");
+
+	// m_NetworkTransmitComponent
+	[SchemaMember("CBaseEntity", "m_NetworkTransmitComponent")]
+	public CNetworkTransmitComponent NetworkTransmitComponent => Schema.GetDeclaredClass<CNetworkTransmitComponent>(this.Handle, "CBaseEntity", "m_NetworkTransmitComponent");
+
+	// m_aThinkFunctions
+	[SchemaMember("CBaseEntity", "m_aThinkFunctions")]
+	public NetworkedVector<thinkfunc_t> ThinkFunctions => Schema.GetDeclaredClass<NetworkedVector<thinkfunc_t>>(this.Handle, "CBaseEntity", "m_aThinkFunctions");
+
+	// m_iCurrentThinkContext
+	[SchemaMember("CBaseEntity", "m_iCurrentThinkContext")]
+	public ref Int32 CurrentThinkContext => ref Schema.GetRef<Int32>(this.Handle, "CBaseEntity", "m_iCurrentThinkContext");
+
+	// m_nLastThinkTick
+	[SchemaMember("CBaseEntity", "m_nLastThinkTick")]
+	public ref Int32 LastThinkTick => ref Schema.GetRef<Int32>(this.Handle, "CBaseEntity", "m_nLastThinkTick");
+
+	// m_nDisableContextThinkStartTick
+	[SchemaMember("CBaseEntity", "m_nDisableContextThinkStartTick")]
+	public ref Int32 DisableContextThinkStartTick => ref Schema.GetRef<Int32>(this.Handle, "CBaseEntity", "m_nDisableContextThinkStartTick");
+
+	// m_isSteadyState
+	[SchemaMember("CBaseEntity", "m_isSteadyState")]
+	public Span<byte> IsSteadyState => Schema.GetFixedArray<byte>(this.Handle, "CBaseEntity", "m_isSteadyState", 8);
+
+	// m_lastNetworkChange
+	[SchemaMember("CBaseEntity", "m_lastNetworkChange")]
+	public ref float LastNetworkChange => ref Schema.GetRef<float>(this.Handle, "CBaseEntity", "m_lastNetworkChange");
+
+	// m_ResponseContexts
+	[SchemaMember("CBaseEntity", "m_ResponseContexts")]
+	public NetworkedVector<ResponseContext_t> ResponseContexts => Schema.GetDeclaredClass<NetworkedVector<ResponseContext_t>>(this.Handle, "CBaseEntity", "m_ResponseContexts");
+
+	// m_iszResponseContext
+	[SchemaMember("CBaseEntity", "m_iszResponseContext")]
+	public string ResponseContext
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseEntity", "m_iszResponseContext"); }
+		set { Schema.SetString(this.Handle, "CBaseEntity", "m_iszResponseContext", value); }
+	}
+
+	// m_iHealth
+	[SchemaMember("CBaseEntity", "m_iHealth")]
+	public ref Int32 Health => ref Schema.GetRef<Int32>(this.Handle, "CBaseEntity", "m_iHealth");
+
+	// m_iMaxHealth
+	[SchemaMember("CBaseEntity", "m_iMaxHealth")]
+	public ref Int32 MaxHealth => ref Schema.GetRef<Int32>(this.Handle, "CBaseEntity", "m_iMaxHealth");
+
+	// m_lifeState
+	[SchemaMember("CBaseEntity", "m_lifeState")]
+	public ref byte LifeState => ref Schema.GetRef<byte>(this.Handle, "CBaseEntity", "m_lifeState");
+
+	// m_flDamageAccumulator
+	[SchemaMember("CBaseEntity", "m_flDamageAccumulator")]
+	public ref float DamageAccumulator => ref Schema.GetRef<float>(this.Handle, "CBaseEntity", "m_flDamageAccumulator");
+
+	// m_bTakesDamage
+	[SchemaMember("CBaseEntity", "m_bTakesDamage")]
+	public ref bool TakesDamage => ref Schema.GetRef<bool>(this.Handle, "CBaseEntity", "m_bTakesDamage");
+
+	// m_nTakeDamageFlags
+	[SchemaMember("CBaseEntity", "m_nTakeDamageFlags")]
+	public ref TakeDamageFlags_t TakeDamageFlags => ref Schema.GetRef<TakeDamageFlags_t>(this.Handle, "CBaseEntity", "m_nTakeDamageFlags");
+
+	// m_bIsPlatform
+	[SchemaMember("CBaseEntity", "m_bIsPlatform")]
+	public ref bool IsPlatform => ref Schema.GetRef<bool>(this.Handle, "CBaseEntity", "m_bIsPlatform");
+
+	// m_MoveCollide
+	[SchemaMember("CBaseEntity", "m_MoveCollide")]
+	public ref MoveCollide_t MoveCollide => ref Schema.GetRef<MoveCollide_t>(this.Handle, "CBaseEntity", "m_MoveCollide");
+
+	// m_MoveType
+	[SchemaMember("CBaseEntity", "m_MoveType")]
+	public ref MoveType_t MoveType => ref Schema.GetRef<MoveType_t>(this.Handle, "CBaseEntity", "m_MoveType");
+
+	// m_nActualMoveType
+	[SchemaMember("CBaseEntity", "m_nActualMoveType")]
+	public ref MoveType_t ActualMoveType => ref Schema.GetRef<MoveType_t>(this.Handle, "CBaseEntity", "m_nActualMoveType");
+
+	// m_nWaterTouch
+	[SchemaMember("CBaseEntity", "m_nWaterTouch")]
+	public ref byte WaterTouch => ref Schema.GetRef<byte>(this.Handle, "CBaseEntity", "m_nWaterTouch");
+
+	// m_nSlimeTouch
+	[SchemaMember("CBaseEntity", "m_nSlimeTouch")]
+	public ref byte SlimeTouch => ref Schema.GetRef<byte>(this.Handle, "CBaseEntity", "m_nSlimeTouch");
+
+	// m_bRestoreInHierarchy
+	[SchemaMember("CBaseEntity", "m_bRestoreInHierarchy")]
+	public ref bool RestoreInHierarchy => ref Schema.GetRef<bool>(this.Handle, "CBaseEntity", "m_bRestoreInHierarchy");
+
+	// m_target
+	[SchemaMember("CBaseEntity", "m_target")]
+	public string Target
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseEntity", "m_target"); }
+		set { Schema.SetString(this.Handle, "CBaseEntity", "m_target", value); }
+	}
+
+	// m_hDamageFilter
+	[SchemaMember("CBaseEntity", "m_hDamageFilter")]
+	public CHandle<CBaseFilter> DamageFilter => Schema.GetDeclaredClass<CHandle<CBaseFilter>>(this.Handle, "CBaseEntity", "m_hDamageFilter");
+
+	// m_iszDamageFilterName
+	[SchemaMember("CBaseEntity", "m_iszDamageFilterName")]
+	public string DamageFilterName
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseEntity", "m_iszDamageFilterName"); }
+		set { Schema.SetString(this.Handle, "CBaseEntity", "m_iszDamageFilterName", value); }
+	}
+
+	// m_flMoveDoneTime
+	[SchemaMember("CBaseEntity", "m_flMoveDoneTime")]
+	public ref float MoveDoneTime => ref Schema.GetRef<float>(this.Handle, "CBaseEntity", "m_flMoveDoneTime");
+
+	// m_nSubclassID
+	[SchemaMember("CBaseEntity", "m_nSubclassID")]
+	public CUtlStringToken SubclassID => Schema.GetDeclaredClass<CUtlStringToken>(this.Handle, "CBaseEntity", "m_nSubclassID");
+
+	// m_flAnimTime
+	[SchemaMember("CBaseEntity", "m_flAnimTime")]
+	public ref float AnimTime => ref Schema.GetRef<float>(this.Handle, "CBaseEntity", "m_flAnimTime");
+
+	// m_flSimulationTime
+	[SchemaMember("CBaseEntity", "m_flSimulationTime")]
+	public ref float SimulationTime => ref Schema.GetRef<float>(this.Handle, "CBaseEntity", "m_flSimulationTime");
+
+	// m_flCreateTime
+	[SchemaMember("CBaseEntity", "m_flCreateTime")]
+	public ref float CreateTime => ref Schema.GetRef<float>(this.Handle, "CBaseEntity", "m_flCreateTime");
+
+	// m_bClientSideRagdoll
+	[SchemaMember("CBaseEntity", "m_bClientSideRagdoll")]
+	public ref bool ClientSideRagdoll => ref Schema.GetRef<bool>(this.Handle, "CBaseEntity", "m_bClientSideRagdoll");
+
+	// m_ubInterpolationFrame
+	[SchemaMember("CBaseEntity", "m_ubInterpolationFrame")]
+	public ref byte InterpolationFrame => ref Schema.GetRef<byte>(this.Handle, "CBaseEntity", "m_ubInterpolationFrame");
+
+	// m_vPrevVPhysicsUpdatePos
+	[SchemaMember("CBaseEntity", "m_vPrevVPhysicsUpdatePos")]
+	public Vector PrevVPhysicsUpdatePos => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseEntity", "m_vPrevVPhysicsUpdatePos");
+
+	// m_iTeamNum
+	[SchemaMember("CBaseEntity", "m_iTeamNum")]
+	public ref byte TeamNum => ref Schema.GetRef<byte>(this.Handle, "CBaseEntity", "m_iTeamNum");
+
+	// m_iGlobalname
+	[SchemaMember("CBaseEntity", "m_iGlobalname")]
+	public string Globalname
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseEntity", "m_iGlobalname"); }
+		set { Schema.SetString(this.Handle, "CBaseEntity", "m_iGlobalname", value); }
+	}
+
+	// m_iSentToClients
+	[SchemaMember("CBaseEntity", "m_iSentToClients")]
+	public ref Int32 SentToClients => ref Schema.GetRef<Int32>(this.Handle, "CBaseEntity", "m_iSentToClients");
+
+	// m_flSpeed
+	[SchemaMember("CBaseEntity", "m_flSpeed")]
+	public ref float Speed => ref Schema.GetRef<float>(this.Handle, "CBaseEntity", "m_flSpeed");
+
+	// m_sUniqueHammerID
+	[SchemaMember("CBaseEntity", "m_sUniqueHammerID")]
+	public string UniqueHammerID
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseEntity", "m_sUniqueHammerID"); }
+		set { Schema.SetString(this.Handle, "CBaseEntity", "m_sUniqueHammerID", value); }
+	}
+
+	// m_spawnflags
+	[SchemaMember("CBaseEntity", "m_spawnflags")]
+	public ref UInt32 Spawnflags => ref Schema.GetRef<UInt32>(this.Handle, "CBaseEntity", "m_spawnflags");
+
+	// m_nNextThinkTick
+	[SchemaMember("CBaseEntity", "m_nNextThinkTick")]
+	public ref Int32 NextThinkTick => ref Schema.GetRef<Int32>(this.Handle, "CBaseEntity", "m_nNextThinkTick");
+
+	// m_nSimulationTick
+	[SchemaMember("CBaseEntity", "m_nSimulationTick")]
+	public ref Int32 SimulationTick => ref Schema.GetRef<Int32>(this.Handle, "CBaseEntity", "m_nSimulationTick");
+
+	// m_OnKilled
+	[SchemaMember("CBaseEntity", "m_OnKilled")]
+	public CEntityIOOutput OnKilled => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseEntity", "m_OnKilled");
+
+	// m_fFlags
+	[SchemaMember("CBaseEntity", "m_fFlags")]
+	public ref UInt32 Flags => ref Schema.GetRef<UInt32>(this.Handle, "CBaseEntity", "m_fFlags");
+
+	// m_vecAbsVelocity
+	[SchemaMember("CBaseEntity", "m_vecAbsVelocity")]
+	public Vector AbsVelocity => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseEntity", "m_vecAbsVelocity");
+
+	// m_vecVelocity
+	[SchemaMember("CBaseEntity", "m_vecVelocity")]
+	public CNetworkVelocityVector Velocity => Schema.GetDeclaredClass<CNetworkVelocityVector>(this.Handle, "CBaseEntity", "m_vecVelocity");
+
+	// m_vecBaseVelocity
+	[SchemaMember("CBaseEntity", "m_vecBaseVelocity")]
+	public Vector BaseVelocity => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseEntity", "m_vecBaseVelocity");
+
+	// m_nPushEnumCount
+	[SchemaMember("CBaseEntity", "m_nPushEnumCount")]
+	public ref Int32 PushEnumCount => ref Schema.GetRef<Int32>(this.Handle, "CBaseEntity", "m_nPushEnumCount");
+
+	// m_pCollision
+	[SchemaMember("CBaseEntity", "m_pCollision")]
+	public CCollisionProperty? Collision => Schema.GetPointer<CCollisionProperty>(this.Handle, "CBaseEntity", "m_pCollision");
+
+	// m_hEffectEntity
+	[SchemaMember("CBaseEntity", "m_hEffectEntity")]
+	public CHandle<CBaseEntity> EffectEntity => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CBaseEntity", "m_hEffectEntity");
+
+	// m_hOwnerEntity
+	[SchemaMember("CBaseEntity", "m_hOwnerEntity")]
+	public CHandle<CBaseEntity> OwnerEntity => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CBaseEntity", "m_hOwnerEntity");
+
+	// m_fEffects
+	[SchemaMember("CBaseEntity", "m_fEffects")]
+	public ref UInt32 Effects => ref Schema.GetRef<UInt32>(this.Handle, "CBaseEntity", "m_fEffects");
+
+	// m_hGroundEntity
+	[SchemaMember("CBaseEntity", "m_hGroundEntity")]
+	public CHandle<CBaseEntity> GroundEntity => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CBaseEntity", "m_hGroundEntity");
+
+	// m_flFriction
+	[SchemaMember("CBaseEntity", "m_flFriction")]
+	public ref float Friction => ref Schema.GetRef<float>(this.Handle, "CBaseEntity", "m_flFriction");
+
+	// m_flElasticity
+	[SchemaMember("CBaseEntity", "m_flElasticity")]
+	public ref float Elasticity => ref Schema.GetRef<float>(this.Handle, "CBaseEntity", "m_flElasticity");
+
+	// m_flGravityScale
+	[SchemaMember("CBaseEntity", "m_flGravityScale")]
+	public ref float GravityScale => ref Schema.GetRef<float>(this.Handle, "CBaseEntity", "m_flGravityScale");
+
+	// m_flTimeScale
+	[SchemaMember("CBaseEntity", "m_flTimeScale")]
+	public ref float TimeScale => ref Schema.GetRef<float>(this.Handle, "CBaseEntity", "m_flTimeScale");
+
+	// m_flWaterLevel
+	[SchemaMember("CBaseEntity", "m_flWaterLevel")]
+	public ref float WaterLevel => ref Schema.GetRef<float>(this.Handle, "CBaseEntity", "m_flWaterLevel");
+
+	// m_bAnimatedEveryTick
+	[SchemaMember("CBaseEntity", "m_bAnimatedEveryTick")]
+	public ref bool AnimatedEveryTick => ref Schema.GetRef<bool>(this.Handle, "CBaseEntity", "m_bAnimatedEveryTick");
+
+	// m_bDisableLowViolence
+	[SchemaMember("CBaseEntity", "m_bDisableLowViolence")]
+	public ref bool DisableLowViolence => ref Schema.GetRef<bool>(this.Handle, "CBaseEntity", "m_bDisableLowViolence");
+
+	// m_nWaterType
+	[SchemaMember("CBaseEntity", "m_nWaterType")]
+	public ref byte WaterType => ref Schema.GetRef<byte>(this.Handle, "CBaseEntity", "m_nWaterType");
+
+	// m_iEFlags
+	[SchemaMember("CBaseEntity", "m_iEFlags")]
+	public ref Int32 EFlags => ref Schema.GetRef<Int32>(this.Handle, "CBaseEntity", "m_iEFlags");
+
+	// m_OnUser1
+	[SchemaMember("CBaseEntity", "m_OnUser1")]
+	public CEntityIOOutput OnUser1 => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseEntity", "m_OnUser1");
+
+	// m_OnUser2
+	[SchemaMember("CBaseEntity", "m_OnUser2")]
+	public CEntityIOOutput OnUser2 => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseEntity", "m_OnUser2");
+
+	// m_OnUser3
+	[SchemaMember("CBaseEntity", "m_OnUser3")]
+	public CEntityIOOutput OnUser3 => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseEntity", "m_OnUser3");
+
+	// m_OnUser4
+	[SchemaMember("CBaseEntity", "m_OnUser4")]
+	public CEntityIOOutput OnUser4 => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseEntity", "m_OnUser4");
+
+	// m_iInitialTeamNum
+	[SchemaMember("CBaseEntity", "m_iInitialTeamNum")]
+	public ref Int32 InitialTeamNum => ref Schema.GetRef<Int32>(this.Handle, "CBaseEntity", "m_iInitialTeamNum");
+
+	// m_flNavIgnoreUntilTime
+	[SchemaMember("CBaseEntity", "m_flNavIgnoreUntilTime")]
+	public ref float NavIgnoreUntilTime => ref Schema.GetRef<float>(this.Handle, "CBaseEntity", "m_flNavIgnoreUntilTime");
+
+	// m_vecAngVelocity
+	[SchemaMember("CBaseEntity", "m_vecAngVelocity")]
+	public QAngle AngVelocity => Schema.GetDeclaredClass<QAngle>(this.Handle, "CBaseEntity", "m_vecAngVelocity");
+
+	// m_bNetworkQuantizeOriginAndAngles
+	[SchemaMember("CBaseEntity", "m_bNetworkQuantizeOriginAndAngles")]
+	public ref bool NetworkQuantizeOriginAndAngles => ref Schema.GetRef<bool>(this.Handle, "CBaseEntity", "m_bNetworkQuantizeOriginAndAngles");
+
+	// m_bLagCompensate
+	[SchemaMember("CBaseEntity", "m_bLagCompensate")]
+	public ref bool LagCompensate => ref Schema.GetRef<bool>(this.Handle, "CBaseEntity", "m_bLagCompensate");
+
+	// m_flOverriddenFriction
+	[SchemaMember("CBaseEntity", "m_flOverriddenFriction")]
+	public ref float OverriddenFriction => ref Schema.GetRef<float>(this.Handle, "CBaseEntity", "m_flOverriddenFriction");
+
+	// m_pBlocker
+	[SchemaMember("CBaseEntity", "m_pBlocker")]
+	public CHandle<CBaseEntity> Blocker => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CBaseEntity", "m_pBlocker");
+
+	// m_flLocalTime
+	[SchemaMember("CBaseEntity", "m_flLocalTime")]
+	public ref float LocalTime => ref Schema.GetRef<float>(this.Handle, "CBaseEntity", "m_flLocalTime");
+
+	// m_flVPhysicsUpdateLocalTime
+	[SchemaMember("CBaseEntity", "m_flVPhysicsUpdateLocalTime")]
+	public ref float VPhysicsUpdateLocalTime => ref Schema.GetRef<float>(this.Handle, "CBaseEntity", "m_flVPhysicsUpdateLocalTime");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseFilter.g.cs

@@ -0,0 +1,33 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseFilter : CLogicalEntity
+{
+    public CBaseFilter (IntPtr pointer) : base(pointer) {}
+
+	// m_bNegated
+	[SchemaMember("CBaseFilter", "m_bNegated")]
+	public ref bool Negated => ref Schema.GetRef<bool>(this.Handle, "CBaseFilter", "m_bNegated");
+
+	// m_OnPass
+	[SchemaMember("CBaseFilter", "m_OnPass")]
+	public CEntityIOOutput OnPass => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseFilter", "m_OnPass");
+
+	// m_OnFail
+	[SchemaMember("CBaseFilter", "m_OnFail")]
+	public CEntityIOOutput OnFail => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseFilter", "m_OnFail");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseFire.g.cs

@@ -0,0 +1,37 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseFire : CBaseEntity
+{
+    public CBaseFire (IntPtr pointer) : base(pointer) {}
+
+	// m_flScale
+	[SchemaMember("CBaseFire", "m_flScale")]
+	public ref float Scale => ref Schema.GetRef<float>(this.Handle, "CBaseFire", "m_flScale");
+
+	// m_flStartScale
+	[SchemaMember("CBaseFire", "m_flStartScale")]
+	public ref float StartScale => ref Schema.GetRef<float>(this.Handle, "CBaseFire", "m_flStartScale");
+
+	// m_flScaleTime
+	[SchemaMember("CBaseFire", "m_flScaleTime")]
+	public ref float ScaleTime => ref Schema.GetRef<float>(this.Handle, "CBaseFire", "m_flScaleTime");
+
+	// m_nFlags
+	[SchemaMember("CBaseFire", "m_nFlags")]
+	public ref UInt32 FireFlags => ref Schema.GetRef<UInt32>(this.Handle, "CBaseFire", "m_nFlags");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseFlex.g.cs

@@ -0,0 +1,49 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseFlex : CBaseAnimGraph
+{
+    public CBaseFlex (IntPtr pointer) : base(pointer) {}
+
+	// m_flexWeight
+	[SchemaMember("CBaseFlex", "m_flexWeight")]
+	public NetworkedVector<float> FlexWeight => Schema.GetDeclaredClass<NetworkedVector<float>>(this.Handle, "CBaseFlex", "m_flexWeight");
+
+	// m_vLookTargetPosition
+	[SchemaMember("CBaseFlex", "m_vLookTargetPosition")]
+	public Vector LookTargetPosition => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseFlex", "m_vLookTargetPosition");
+
+	// m_blinktoggle
+	[SchemaMember("CBaseFlex", "m_blinktoggle")]
+	public ref bool Blinktoggle => ref Schema.GetRef<bool>(this.Handle, "CBaseFlex", "m_blinktoggle");
+
+	// m_flAllowResponsesEndTime
+	[SchemaMember("CBaseFlex", "m_flAllowResponsesEndTime")]
+	public ref float AllowResponsesEndTime => ref Schema.GetRef<float>(this.Handle, "CBaseFlex", "m_flAllowResponsesEndTime");
+
+	// m_flLastFlexAnimationTime
+	[SchemaMember("CBaseFlex", "m_flLastFlexAnimationTime")]
+	public ref float LastFlexAnimationTime => ref Schema.GetRef<float>(this.Handle, "CBaseFlex", "m_flLastFlexAnimationTime");
+
+	// m_nNextSceneEventId
+	[SchemaMember("CBaseFlex", "m_nNextSceneEventId")]
+	public ref UInt32 NextSceneEventId => ref Schema.GetRef<UInt32>(this.Handle, "CBaseFlex", "m_nNextSceneEventId");
+
+	// m_bUpdateLayerPriorities
+	[SchemaMember("CBaseFlex", "m_bUpdateLayerPriorities")]
+	public ref bool UpdateLayerPriorities => ref Schema.GetRef<bool>(this.Handle, "CBaseFlex", "m_bUpdateLayerPriorities");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseFlexAlias_funCBaseFlex.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseFlexAlias_funCBaseFlex : CBaseFlex
+{
+    public CBaseFlexAlias_funCBaseFlex (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseGrenade.g.cs

@@ -0,0 +1,85 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseGrenade : CBaseFlex
+{
+    public CBaseGrenade (IntPtr pointer) : base(pointer) {}
+
+	// m_OnPlayerPickup
+	[SchemaMember("CBaseGrenade", "m_OnPlayerPickup")]
+	public CEntityIOOutput OnPlayerPickup => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseGrenade", "m_OnPlayerPickup");
+
+	// m_OnExplode
+	[SchemaMember("CBaseGrenade", "m_OnExplode")]
+	public CEntityIOOutput OnExplode => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseGrenade", "m_OnExplode");
+
+	// m_bHasWarnedAI
+	[SchemaMember("CBaseGrenade", "m_bHasWarnedAI")]
+	public ref bool HasWarnedAI => ref Schema.GetRef<bool>(this.Handle, "CBaseGrenade", "m_bHasWarnedAI");
+
+	// m_bIsSmokeGrenade
+	[SchemaMember("CBaseGrenade", "m_bIsSmokeGrenade")]
+	public ref bool IsSmokeGrenade => ref Schema.GetRef<bool>(this.Handle, "CBaseGrenade", "m_bIsSmokeGrenade");
+
+	// m_bIsLive
+	[SchemaMember("CBaseGrenade", "m_bIsLive")]
+	public ref bool IsLive => ref Schema.GetRef<bool>(this.Handle, "CBaseGrenade", "m_bIsLive");
+
+	// m_DmgRadius
+	[SchemaMember("CBaseGrenade", "m_DmgRadius")]
+	public ref float DmgRadius => ref Schema.GetRef<float>(this.Handle, "CBaseGrenade", "m_DmgRadius");
+
+	// m_flDetonateTime
+	[SchemaMember("CBaseGrenade", "m_flDetonateTime")]
+	public ref float DetonateTime => ref Schema.GetRef<float>(this.Handle, "CBaseGrenade", "m_flDetonateTime");
+
+	// m_flWarnAITime
+	[SchemaMember("CBaseGrenade", "m_flWarnAITime")]
+	public ref float WarnAITime => ref Schema.GetRef<float>(this.Handle, "CBaseGrenade", "m_flWarnAITime");
+
+	// m_flDamage
+	[SchemaMember("CBaseGrenade", "m_flDamage")]
+	public ref float Damage => ref Schema.GetRef<float>(this.Handle, "CBaseGrenade", "m_flDamage");
+
+	// m_iszBounceSound
+	[SchemaMember("CBaseGrenade", "m_iszBounceSound")]
+	public string BounceSound
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseGrenade", "m_iszBounceSound"); }
+		set { Schema.SetString(this.Handle, "CBaseGrenade", "m_iszBounceSound", value); }
+	}
+
+	// m_ExplosionSound
+	[SchemaMember("CBaseGrenade", "m_ExplosionSound")]
+	public string ExplosionSound
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseGrenade", "m_ExplosionSound"); }
+		set { Schema.SetString(this.Handle, "CBaseGrenade", "m_ExplosionSound", value); }
+	}
+
+	// m_hThrower
+	[SchemaMember("CBaseGrenade", "m_hThrower")]
+	public CHandle<CCSPlayerPawn> Thrower => Schema.GetDeclaredClass<CHandle<CCSPlayerPawn>>(this.Handle, "CBaseGrenade", "m_hThrower");
+
+	// m_flNextAttack
+	[SchemaMember("CBaseGrenade", "m_flNextAttack")]
+	public ref float NextAttack => ref Schema.GetRef<float>(this.Handle, "CBaseGrenade", "m_flNextAttack");
+
+	// m_hOriginalThrower
+	[SchemaMember("CBaseGrenade", "m_hOriginalThrower")]
+	public CHandle<CCSPlayerPawn> OriginalThrower => Schema.GetDeclaredClass<CHandle<CCSPlayerPawn>>(this.Handle, "CBaseGrenade", "m_hOriginalThrower");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseIssue.g.cs

@@ -0,0 +1,53 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseIssue : NativeObject
+{
+    public CBaseIssue (IntPtr pointer) : base(pointer) {}
+
+	// m_szTypeString
+	[SchemaMember("CBaseIssue", "m_szTypeString")]
+	public string TypeString
+	{
+		get { return Schema.GetString(this.Handle, "CBaseIssue", "m_szTypeString"); }
+		set { Schema.SetString(this.Handle, "CBaseIssue", "m_szTypeString", value); }
+	}
+
+	// m_szDetailsString
+	[SchemaMember("CBaseIssue", "m_szDetailsString")]
+	public string DetailsString
+	{
+		get { return Schema.GetString(this.Handle, "CBaseIssue", "m_szDetailsString"); }
+		set { Schema.SetString(this.Handle, "CBaseIssue", "m_szDetailsString", value); }
+	}
+
+	// m_iNumYesVotes
+	[SchemaMember("CBaseIssue", "m_iNumYesVotes")]
+	public ref Int32 NumYesVotes => ref Schema.GetRef<Int32>(this.Handle, "CBaseIssue", "m_iNumYesVotes");
+
+	// m_iNumNoVotes
+	[SchemaMember("CBaseIssue", "m_iNumNoVotes")]
+	public ref Int32 NumNoVotes => ref Schema.GetRef<Int32>(this.Handle, "CBaseIssue", "m_iNumNoVotes");
+
+	// m_iNumPotentialVotes
+	[SchemaMember("CBaseIssue", "m_iNumPotentialVotes")]
+	public ref Int32 NumPotentialVotes => ref Schema.GetRef<Int32>(this.Handle, "CBaseIssue", "m_iNumPotentialVotes");
+
+	// m_pVoteController
+	[SchemaMember("CBaseIssue", "m_pVoteController")]
+	public CVoteController? VoteController => Schema.GetPointer<CVoteController>(this.Handle, "CBaseIssue", "m_pVoteController");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseModelEntity.g.cs

@@ -0,0 +1,125 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseModelEntity : CBaseEntity
+{
+    public CBaseModelEntity (IntPtr pointer) : base(pointer) {}
+
+	// m_CRenderComponent
+	[SchemaMember("CBaseModelEntity", "m_CRenderComponent")]
+	public CRenderComponent? CRenderComponent => Schema.GetPointer<CRenderComponent>(this.Handle, "CBaseModelEntity", "m_CRenderComponent");
+
+	// m_CHitboxComponent
+	[SchemaMember("CBaseModelEntity", "m_CHitboxComponent")]
+	public CHitboxComponent CHitboxComponent => Schema.GetDeclaredClass<CHitboxComponent>(this.Handle, "CBaseModelEntity", "m_CHitboxComponent");
+
+	// m_flDissolveStartTime
+	[SchemaMember("CBaseModelEntity", "m_flDissolveStartTime")]
+	public ref float DissolveStartTime => ref Schema.GetRef<float>(this.Handle, "CBaseModelEntity", "m_flDissolveStartTime");
+
+	// m_OnIgnite
+	[SchemaMember("CBaseModelEntity", "m_OnIgnite")]
+	public CEntityIOOutput OnIgnite => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseModelEntity", "m_OnIgnite");
+
+	// m_nRenderMode
+	[SchemaMember("CBaseModelEntity", "m_nRenderMode")]
+	public ref RenderMode_t RenderMode => ref Schema.GetRef<RenderMode_t>(this.Handle, "CBaseModelEntity", "m_nRenderMode");
+
+	// m_nRenderFX
+	[SchemaMember("CBaseModelEntity", "m_nRenderFX")]
+	public ref RenderFx_t RenderFX => ref Schema.GetRef<RenderFx_t>(this.Handle, "CBaseModelEntity", "m_nRenderFX");
+
+	// m_bAllowFadeInView
+	[SchemaMember("CBaseModelEntity", "m_bAllowFadeInView")]
+	public ref bool AllowFadeInView => ref Schema.GetRef<bool>(this.Handle, "CBaseModelEntity", "m_bAllowFadeInView");
+
+	// m_clrRender
+	[SchemaMember("CBaseModelEntity", "m_clrRender")]
+	public Color Render
+	{
+		get { return Schema.GetCustomMarshalledType<Color>(this.Handle, "CBaseModelEntity", "m_clrRender"); }
+		set { Schema.SetCustomMarshalledType<Color>(this.Handle, "CBaseModelEntity", "m_clrRender", value); }
+	}
+
+	// m_vecRenderAttributes
+	[SchemaMember("CBaseModelEntity", "m_vecRenderAttributes")]
+	public NetworkedVector<EntityRenderAttribute_t> RenderAttributes => Schema.GetDeclaredClass<NetworkedVector<EntityRenderAttribute_t>>(this.Handle, "CBaseModelEntity", "m_vecRenderAttributes");
+
+	// m_bRenderToCubemaps
+	[SchemaMember("CBaseModelEntity", "m_bRenderToCubemaps")]
+	public ref bool RenderToCubemaps => ref Schema.GetRef<bool>(this.Handle, "CBaseModelEntity", "m_bRenderToCubemaps");
+
+	// m_Collision
+	[SchemaMember("CBaseModelEntity", "m_Collision")]
+	public CCollisionProperty Collision => Schema.GetDeclaredClass<CCollisionProperty>(this.Handle, "CBaseModelEntity", "m_Collision");
+
+	// m_Glow
+	[SchemaMember("CBaseModelEntity", "m_Glow")]
+	public CGlowProperty Glow => Schema.GetDeclaredClass<CGlowProperty>(this.Handle, "CBaseModelEntity", "m_Glow");
+
+	// m_flGlowBackfaceMult
+	[SchemaMember("CBaseModelEntity", "m_flGlowBackfaceMult")]
+	public ref float GlowBackfaceMult => ref Schema.GetRef<float>(this.Handle, "CBaseModelEntity", "m_flGlowBackfaceMult");
+
+	// m_fadeMinDist
+	[SchemaMember("CBaseModelEntity", "m_fadeMinDist")]
+	public ref float FadeMinDist => ref Schema.GetRef<float>(this.Handle, "CBaseModelEntity", "m_fadeMinDist");
+
+	// m_fadeMaxDist
+	[SchemaMember("CBaseModelEntity", "m_fadeMaxDist")]
+	public ref float FadeMaxDist => ref Schema.GetRef<float>(this.Handle, "CBaseModelEntity", "m_fadeMaxDist");
+
+	// m_flFadeScale
+	[SchemaMember("CBaseModelEntity", "m_flFadeScale")]
+	public ref float FadeScale => ref Schema.GetRef<float>(this.Handle, "CBaseModelEntity", "m_flFadeScale");
+
+	// m_flShadowStrength
+	[SchemaMember("CBaseModelEntity", "m_flShadowStrength")]
+	public ref float ShadowStrength => ref Schema.GetRef<float>(this.Handle, "CBaseModelEntity", "m_flShadowStrength");
+
+	// m_nObjectCulling
+	[SchemaMember("CBaseModelEntity", "m_nObjectCulling")]
+	public ref byte ObjectCulling => ref Schema.GetRef<byte>(this.Handle, "CBaseModelEntity", "m_nObjectCulling");
+
+	// m_nAddDecal
+	[SchemaMember("CBaseModelEntity", "m_nAddDecal")]
+	public ref Int32 AddDecal => ref Schema.GetRef<Int32>(this.Handle, "CBaseModelEntity", "m_nAddDecal");
+
+	// m_vDecalPosition
+	[SchemaMember("CBaseModelEntity", "m_vDecalPosition")]
+	public Vector DecalPosition => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseModelEntity", "m_vDecalPosition");
+
+	// m_vDecalForwardAxis
+	[SchemaMember("CBaseModelEntity", "m_vDecalForwardAxis")]
+	public Vector DecalForwardAxis => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseModelEntity", "m_vDecalForwardAxis");
+
+	// m_flDecalHealBloodRate
+	[SchemaMember("CBaseModelEntity", "m_flDecalHealBloodRate")]
+	public ref float DecalHealBloodRate => ref Schema.GetRef<float>(this.Handle, "CBaseModelEntity", "m_flDecalHealBloodRate");
+
+	// m_flDecalHealHeightRate
+	[SchemaMember("CBaseModelEntity", "m_flDecalHealHeightRate")]
+	public ref float DecalHealHeightRate => ref Schema.GetRef<float>(this.Handle, "CBaseModelEntity", "m_flDecalHealHeightRate");
+
+	// m_ConfigEntitiesToPropagateMaterialDecalsTo
+	[SchemaMember("CBaseModelEntity", "m_ConfigEntitiesToPropagateMaterialDecalsTo")]
+	public NetworkedVector<CHandle<CBaseModelEntity>> ConfigEntitiesToPropagateMaterialDecalsTo => Schema.GetDeclaredClass<NetworkedVector<CHandle<CBaseModelEntity>>>(this.Handle, "CBaseModelEntity", "m_ConfigEntitiesToPropagateMaterialDecalsTo");
+
+	// m_vecViewOffset
+	[SchemaMember("CBaseModelEntity", "m_vecViewOffset")]
+	public CNetworkViewOffsetVector ViewOffset => Schema.GetDeclaredClass<CNetworkViewOffsetVector>(this.Handle, "CBaseModelEntity", "m_vecViewOffset");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseMoveBehavior.g.cs

@@ -0,0 +1,65 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseMoveBehavior : CPathKeyFrame
+{
+    public CBaseMoveBehavior (IntPtr pointer) : base(pointer) {}
+
+	// m_iPositionInterpolator
+	[SchemaMember("CBaseMoveBehavior", "m_iPositionInterpolator")]
+	public ref Int32 PositionInterpolator => ref Schema.GetRef<Int32>(this.Handle, "CBaseMoveBehavior", "m_iPositionInterpolator");
+
+	// m_iRotationInterpolator
+	[SchemaMember("CBaseMoveBehavior", "m_iRotationInterpolator")]
+	public ref Int32 RotationInterpolator => ref Schema.GetRef<Int32>(this.Handle, "CBaseMoveBehavior", "m_iRotationInterpolator");
+
+	// m_flAnimStartTime
+	[SchemaMember("CBaseMoveBehavior", "m_flAnimStartTime")]
+	public ref float AnimStartTime => ref Schema.GetRef<float>(this.Handle, "CBaseMoveBehavior", "m_flAnimStartTime");
+
+	// m_flAnimEndTime
+	[SchemaMember("CBaseMoveBehavior", "m_flAnimEndTime")]
+	public ref float AnimEndTime => ref Schema.GetRef<float>(this.Handle, "CBaseMoveBehavior", "m_flAnimEndTime");
+
+	// m_flAverageSpeedAcrossFrame
+	[SchemaMember("CBaseMoveBehavior", "m_flAverageSpeedAcrossFrame")]
+	public ref float AverageSpeedAcrossFrame => ref Schema.GetRef<float>(this.Handle, "CBaseMoveBehavior", "m_flAverageSpeedAcrossFrame");
+
+	// m_pCurrentKeyFrame
+	[SchemaMember("CBaseMoveBehavior", "m_pCurrentKeyFrame")]
+	public CPathKeyFrame? CurrentKeyFrame => Schema.GetPointer<CPathKeyFrame>(this.Handle, "CBaseMoveBehavior", "m_pCurrentKeyFrame");
+
+	// m_pTargetKeyFrame
+	[SchemaMember("CBaseMoveBehavior", "m_pTargetKeyFrame")]
+	public CPathKeyFrame? TargetKeyFrame => Schema.GetPointer<CPathKeyFrame>(this.Handle, "CBaseMoveBehavior", "m_pTargetKeyFrame");
+
+	// m_pPreKeyFrame
+	[SchemaMember("CBaseMoveBehavior", "m_pPreKeyFrame")]
+	public CPathKeyFrame? PreKeyFrame => Schema.GetPointer<CPathKeyFrame>(this.Handle, "CBaseMoveBehavior", "m_pPreKeyFrame");
+
+	// m_pPostKeyFrame
+	[SchemaMember("CBaseMoveBehavior", "m_pPostKeyFrame")]
+	public CPathKeyFrame? PostKeyFrame => Schema.GetPointer<CPathKeyFrame>(this.Handle, "CBaseMoveBehavior", "m_pPostKeyFrame");
+
+	// m_flTimeIntoFrame
+	[SchemaMember("CBaseMoveBehavior", "m_flTimeIntoFrame")]
+	public ref float TimeIntoFrame => ref Schema.GetRef<float>(this.Handle, "CBaseMoveBehavior", "m_flTimeIntoFrame");
+
+	// m_iDirection
+	[SchemaMember("CBaseMoveBehavior", "m_iDirection")]
+	public ref Int32 Direction => ref Schema.GetRef<Int32>(this.Handle, "CBaseMoveBehavior", "m_iDirection");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBasePlatTrain.g.cs

@@ -0,0 +1,49 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBasePlatTrain : CBaseToggle
+{
+    public CBasePlatTrain (IntPtr pointer) : base(pointer) {}
+
+	// m_NoiseMoving
+	[SchemaMember("CBasePlatTrain", "m_NoiseMoving")]
+	public string NoiseMoving
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBasePlatTrain", "m_NoiseMoving"); }
+		set { Schema.SetString(this.Handle, "CBasePlatTrain", "m_NoiseMoving", value); }
+	}
+
+	// m_NoiseArrived
+	[SchemaMember("CBasePlatTrain", "m_NoiseArrived")]
+	public string NoiseArrived
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBasePlatTrain", "m_NoiseArrived"); }
+		set { Schema.SetString(this.Handle, "CBasePlatTrain", "m_NoiseArrived", value); }
+	}
+
+	// m_volume
+	[SchemaMember("CBasePlatTrain", "m_volume")]
+	public ref float Volume => ref Schema.GetRef<float>(this.Handle, "CBasePlatTrain", "m_volume");
+
+	// m_flTWidth
+	[SchemaMember("CBasePlatTrain", "m_flTWidth")]
+	public ref float TWidth => ref Schema.GetRef<float>(this.Handle, "CBasePlatTrain", "m_flTWidth");
+
+	// m_flTLength
+	[SchemaMember("CBasePlatTrain", "m_flTLength")]
+	public ref float TLength => ref Schema.GetRef<float>(this.Handle, "CBasePlatTrain", "m_flTLength");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBasePlayerController.g.cs

@@ -0,0 +1,129 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBasePlayerController : CBaseEntity
+{
+    public CBasePlayerController (IntPtr pointer) : base(pointer) {}
+
+	// m_nInButtonsWhichAreToggles
+	[SchemaMember("CBasePlayerController", "m_nInButtonsWhichAreToggles")]
+	public ref UInt64 InButtonsWhichAreToggles => ref Schema.GetRef<UInt64>(this.Handle, "CBasePlayerController", "m_nInButtonsWhichAreToggles");
+
+	// m_nTickBase
+	[SchemaMember("CBasePlayerController", "m_nTickBase")]
+	public ref UInt32 TickBase => ref Schema.GetRef<UInt32>(this.Handle, "CBasePlayerController", "m_nTickBase");
+
+	// m_hPawn
+	[SchemaMember("CBasePlayerController", "m_hPawn")]
+	public CHandle<CBasePlayerPawn> Pawn => Schema.GetDeclaredClass<CHandle<CBasePlayerPawn>>(this.Handle, "CBasePlayerController", "m_hPawn");
+
+	// m_nSplitScreenSlot
+	[SchemaMember("CBasePlayerController", "m_nSplitScreenSlot")]
+	public ref Int32 SplitScreenSlot => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerController", "m_nSplitScreenSlot");
+
+	// m_hSplitOwner
+	[SchemaMember("CBasePlayerController", "m_hSplitOwner")]
+	public CHandle<CBasePlayerController> SplitOwner => Schema.GetDeclaredClass<CHandle<CBasePlayerController>>(this.Handle, "CBasePlayerController", "m_hSplitOwner");
+
+	// m_hSplitScreenPlayers
+	[SchemaMember("CBasePlayerController", "m_hSplitScreenPlayers")]
+	public NetworkedVector<CHandle<CBasePlayerController>> SplitScreenPlayers => Schema.GetDeclaredClass<NetworkedVector<CHandle<CBasePlayerController>>>(this.Handle, "CBasePlayerController", "m_hSplitScreenPlayers");
+
+	// m_bIsHLTV
+	[SchemaMember("CBasePlayerController", "m_bIsHLTV")]
+	public ref bool IsHLTV => ref Schema.GetRef<bool>(this.Handle, "CBasePlayerController", "m_bIsHLTV");
+
+	// m_iConnected
+	[SchemaMember("CBasePlayerController", "m_iConnected")]
+	public ref PlayerConnectedState Connected => ref Schema.GetRef<PlayerConnectedState>(this.Handle, "CBasePlayerController", "m_iConnected");
+
+	// m_iszPlayerName
+	[SchemaMember("CBasePlayerController", "m_iszPlayerName")]
+	public string PlayerName
+	{
+		get { return Schema.GetString(this.Handle, "CBasePlayerController", "m_iszPlayerName"); }
+		set { Schema.SetString(this.Handle, "CBasePlayerController", "m_iszPlayerName", value); }
+	}
+
+	// m_szNetworkIDString
+	[SchemaMember("CBasePlayerController", "m_szNetworkIDString")]
+	public string NetworkIDString
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBasePlayerController", "m_szNetworkIDString"); }
+		set { Schema.SetString(this.Handle, "CBasePlayerController", "m_szNetworkIDString", value); }
+	}
+
+	// m_fLerpTime
+	[SchemaMember("CBasePlayerController", "m_fLerpTime")]
+	public ref float LerpTime => ref Schema.GetRef<float>(this.Handle, "CBasePlayerController", "m_fLerpTime");
+
+	// m_bLagCompensation
+	[SchemaMember("CBasePlayerController", "m_bLagCompensation")]
+	public ref bool LagCompensation => ref Schema.GetRef<bool>(this.Handle, "CBasePlayerController", "m_bLagCompensation");
+
+	// m_bPredict
+	[SchemaMember("CBasePlayerController", "m_bPredict")]
+	public ref bool Predict => ref Schema.GetRef<bool>(this.Handle, "CBasePlayerController", "m_bPredict");
+
+	// m_bAutoKickDisabled
+	[SchemaMember("CBasePlayerController", "m_bAutoKickDisabled")]
+	public ref bool AutoKickDisabled => ref Schema.GetRef<bool>(this.Handle, "CBasePlayerController", "m_bAutoKickDisabled");
+
+	// m_bIsLowViolence
+	[SchemaMember("CBasePlayerController", "m_bIsLowViolence")]
+	public ref bool IsLowViolence => ref Schema.GetRef<bool>(this.Handle, "CBasePlayerController", "m_bIsLowViolence");
+
+	// m_bGamePaused
+	[SchemaMember("CBasePlayerController", "m_bGamePaused")]
+	public ref bool GamePaused => ref Schema.GetRef<bool>(this.Handle, "CBasePlayerController", "m_bGamePaused");
+
+	// m_nLastRealCommandNumberExecuted
+	[SchemaMember("CBasePlayerController", "m_nLastRealCommandNumberExecuted")]
+	public ref Int32 LastRealCommandNumberExecuted => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerController", "m_nLastRealCommandNumberExecuted");
+
+	// m_nLastLateCommandExecuted
+	[SchemaMember("CBasePlayerController", "m_nLastLateCommandExecuted")]
+	public ref Int32 LastLateCommandExecuted => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerController", "m_nLastLateCommandExecuted");
+
+	// m_iIgnoreGlobalChat
+	[SchemaMember("CBasePlayerController", "m_iIgnoreGlobalChat")]
+	public ref ChatIgnoreType_t IgnoreGlobalChat => ref Schema.GetRef<ChatIgnoreType_t>(this.Handle, "CBasePlayerController", "m_iIgnoreGlobalChat");
+
+	// m_flLastPlayerTalkTime
+	[SchemaMember("CBasePlayerController", "m_flLastPlayerTalkTime")]
+	public ref float LastPlayerTalkTime => ref Schema.GetRef<float>(this.Handle, "CBasePlayerController", "m_flLastPlayerTalkTime");
+
+	// m_flLastEntitySteadyState
+	[SchemaMember("CBasePlayerController", "m_flLastEntitySteadyState")]
+	public ref float LastEntitySteadyState => ref Schema.GetRef<float>(this.Handle, "CBasePlayerController", "m_flLastEntitySteadyState");
+
+	// m_nAvailableEntitySteadyState
+	[SchemaMember("CBasePlayerController", "m_nAvailableEntitySteadyState")]
+	public ref Int32 AvailableEntitySteadyState => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerController", "m_nAvailableEntitySteadyState");
+
+	// m_bHasAnySteadyStateEnts
+	[SchemaMember("CBasePlayerController", "m_bHasAnySteadyStateEnts")]
+	public ref bool HasAnySteadyStateEnts => ref Schema.GetRef<bool>(this.Handle, "CBasePlayerController", "m_bHasAnySteadyStateEnts");
+
+	// m_steamID
+	[SchemaMember("CBasePlayerController", "m_steamID")]
+	public ref UInt64 SteamID => ref Schema.GetRef<UInt64>(this.Handle, "CBasePlayerController", "m_steamID");
+
+	// m_iDesiredFOV
+	[SchemaMember("CBasePlayerController", "m_iDesiredFOV")]
+	public ref UInt32 DesiredFOV => ref Schema.GetRef<UInt32>(this.Handle, "CBasePlayerController", "m_iDesiredFOV");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBasePlayerPawn.g.cs

@@ -0,0 +1,121 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBasePlayerPawn : CBaseCombatCharacter
+{
+    public CBasePlayerPawn (IntPtr pointer) : base(pointer) {}
+
+	// m_pWeaponServices
+	[SchemaMember("CBasePlayerPawn", "m_pWeaponServices")]
+	public CPlayer_WeaponServices? WeaponServices => Schema.GetPointer<CPlayer_WeaponServices>(this.Handle, "CBasePlayerPawn", "m_pWeaponServices");
+
+	// m_pItemServices
+	[SchemaMember("CBasePlayerPawn", "m_pItemServices")]
+	public CPlayer_ItemServices? ItemServices => Schema.GetPointer<CPlayer_ItemServices>(this.Handle, "CBasePlayerPawn", "m_pItemServices");
+
+	// m_pAutoaimServices
+	[SchemaMember("CBasePlayerPawn", "m_pAutoaimServices")]
+	public CPlayer_AutoaimServices? AutoaimServices => Schema.GetPointer<CPlayer_AutoaimServices>(this.Handle, "CBasePlayerPawn", "m_pAutoaimServices");
+
+	// m_pObserverServices
+	[SchemaMember("CBasePlayerPawn", "m_pObserverServices")]
+	public CPlayer_ObserverServices? ObserverServices => Schema.GetPointer<CPlayer_ObserverServices>(this.Handle, "CBasePlayerPawn", "m_pObserverServices");
+
+	// m_pWaterServices
+	[SchemaMember("CBasePlayerPawn", "m_pWaterServices")]
+	public CPlayer_WaterServices? WaterServices => Schema.GetPointer<CPlayer_WaterServices>(this.Handle, "CBasePlayerPawn", "m_pWaterServices");
+
+	// m_pUseServices
+	[SchemaMember("CBasePlayerPawn", "m_pUseServices")]
+	public CPlayer_UseServices? UseServices => Schema.GetPointer<CPlayer_UseServices>(this.Handle, "CBasePlayerPawn", "m_pUseServices");
+
+	// m_pFlashlightServices
+	[SchemaMember("CBasePlayerPawn", "m_pFlashlightServices")]
+	public CPlayer_FlashlightServices? FlashlightServices => Schema.GetPointer<CPlayer_FlashlightServices>(this.Handle, "CBasePlayerPawn", "m_pFlashlightServices");
+
+	// m_pCameraServices
+	[SchemaMember("CBasePlayerPawn", "m_pCameraServices")]
+	public CPlayer_CameraServices? CameraServices => Schema.GetPointer<CPlayer_CameraServices>(this.Handle, "CBasePlayerPawn", "m_pCameraServices");
+
+	// m_pMovementServices
+	[SchemaMember("CBasePlayerPawn", "m_pMovementServices")]
+	public CPlayer_MovementServices? MovementServices => Schema.GetPointer<CPlayer_MovementServices>(this.Handle, "CBasePlayerPawn", "m_pMovementServices");
+
+	// m_ServerViewAngleChanges
+	[SchemaMember("CBasePlayerPawn", "m_ServerViewAngleChanges")]
+	public NetworkedVector<ViewAngleServerChange_t> ServerViewAngleChanges => Schema.GetDeclaredClass<NetworkedVector<ViewAngleServerChange_t>>(this.Handle, "CBasePlayerPawn", "m_ServerViewAngleChanges");
+
+	// m_nHighestGeneratedServerViewAngleChangeIndex
+	[SchemaMember("CBasePlayerPawn", "m_nHighestGeneratedServerViewAngleChangeIndex")]
+	public ref UInt32 HighestGeneratedServerViewAngleChangeIndex => ref Schema.GetRef<UInt32>(this.Handle, "CBasePlayerPawn", "m_nHighestGeneratedServerViewAngleChangeIndex");
+
+	// v_angle
+	[SchemaMember("CBasePlayerPawn", "v_angle")]
+	public QAngle V_angle => Schema.GetDeclaredClass<QAngle>(this.Handle, "CBasePlayerPawn", "v_angle");
+
+	// v_anglePrevious
+	[SchemaMember("CBasePlayerPawn", "v_anglePrevious")]
+	public QAngle V_anglePrevious => Schema.GetDeclaredClass<QAngle>(this.Handle, "CBasePlayerPawn", "v_anglePrevious");
+
+	// m_iHideHUD
+	[SchemaMember("CBasePlayerPawn", "m_iHideHUD")]
+	public ref UInt32 HideHUD => ref Schema.GetRef<UInt32>(this.Handle, "CBasePlayerPawn", "m_iHideHUD");
+
+	// m_skybox3d
+	[SchemaMember("CBasePlayerPawn", "m_skybox3d")]
+	public sky3dparams_t Skybox3d => Schema.GetDeclaredClass<sky3dparams_t>(this.Handle, "CBasePlayerPawn", "m_skybox3d");
+
+	// m_fTimeLastHurt
+	[SchemaMember("CBasePlayerPawn", "m_fTimeLastHurt")]
+	public ref float TimeLastHurt => ref Schema.GetRef<float>(this.Handle, "CBasePlayerPawn", "m_fTimeLastHurt");
+
+	// m_flDeathTime
+	[SchemaMember("CBasePlayerPawn", "m_flDeathTime")]
+	public ref float DeathTime => ref Schema.GetRef<float>(this.Handle, "CBasePlayerPawn", "m_flDeathTime");
+
+	// m_fNextSuicideTime
+	[SchemaMember("CBasePlayerPawn", "m_fNextSuicideTime")]
+	public ref float NextSuicideTime => ref Schema.GetRef<float>(this.Handle, "CBasePlayerPawn", "m_fNextSuicideTime");
+
+	// m_fInitHUD
+	[SchemaMember("CBasePlayerPawn", "m_fInitHUD")]
+	public ref bool InitHUD => ref Schema.GetRef<bool>(this.Handle, "CBasePlayerPawn", "m_fInitHUD");
+
+	// m_pExpresser
+	[SchemaMember("CBasePlayerPawn", "m_pExpresser")]
+	public CAI_Expresser? Expresser => Schema.GetPointer<CAI_Expresser>(this.Handle, "CBasePlayerPawn", "m_pExpresser");
+
+	// m_hController
+	[SchemaMember("CBasePlayerPawn", "m_hController")]
+	public CHandle<CBasePlayerController> Controller => Schema.GetDeclaredClass<CHandle<CBasePlayerController>>(this.Handle, "CBasePlayerPawn", "m_hController");
+
+	// m_fHltvReplayDelay
+	[SchemaMember("CBasePlayerPawn", "m_fHltvReplayDelay")]
+	public ref float HltvReplayDelay => ref Schema.GetRef<float>(this.Handle, "CBasePlayerPawn", "m_fHltvReplayDelay");
+
+	// m_fHltvReplayEnd
+	[SchemaMember("CBasePlayerPawn", "m_fHltvReplayEnd")]
+	public ref float HltvReplayEnd => ref Schema.GetRef<float>(this.Handle, "CBasePlayerPawn", "m_fHltvReplayEnd");
+
+	// m_iHltvReplayEntity
+	[SchemaMember("CBasePlayerPawn", "m_iHltvReplayEntity")]
+	public CEntityIndex HltvReplayEntity => Schema.GetDeclaredClass<CEntityIndex>(this.Handle, "CBasePlayerPawn", "m_iHltvReplayEntity");
+
+	// m_sndOpvarLatchData
+	[SchemaMember("CBasePlayerPawn", "m_sndOpvarLatchData")]
+	public NetworkedVector<sndopvarlatchdata_t> SndOpvarLatchData => Schema.GetDeclaredClass<NetworkedVector<sndopvarlatchdata_t>>(this.Handle, "CBasePlayerPawn", "m_sndOpvarLatchData");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBasePlayerVData.g.cs

@@ -0,0 +1,73 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBasePlayerVData : CEntitySubclassVDataBase
+{
+    public CBasePlayerVData (IntPtr pointer) : base(pointer) {}
+
+	// m_flHeadDamageMultiplier
+	[SchemaMember("CBasePlayerVData", "m_flHeadDamageMultiplier")]
+	public CSkillFloat HeadDamageMultiplier => Schema.GetDeclaredClass<CSkillFloat>(this.Handle, "CBasePlayerVData", "m_flHeadDamageMultiplier");
+
+	// m_flChestDamageMultiplier
+	[SchemaMember("CBasePlayerVData", "m_flChestDamageMultiplier")]
+	public CSkillFloat ChestDamageMultiplier => Schema.GetDeclaredClass<CSkillFloat>(this.Handle, "CBasePlayerVData", "m_flChestDamageMultiplier");
+
+	// m_flStomachDamageMultiplier
+	[SchemaMember("CBasePlayerVData", "m_flStomachDamageMultiplier")]
+	public CSkillFloat StomachDamageMultiplier => Schema.GetDeclaredClass<CSkillFloat>(this.Handle, "CBasePlayerVData", "m_flStomachDamageMultiplier");
+
+	// m_flArmDamageMultiplier
+	[SchemaMember("CBasePlayerVData", "m_flArmDamageMultiplier")]
+	public CSkillFloat ArmDamageMultiplier => Schema.GetDeclaredClass<CSkillFloat>(this.Handle, "CBasePlayerVData", "m_flArmDamageMultiplier");
+
+	// m_flLegDamageMultiplier
+	[SchemaMember("CBasePlayerVData", "m_flLegDamageMultiplier")]
+	public CSkillFloat LegDamageMultiplier => Schema.GetDeclaredClass<CSkillFloat>(this.Handle, "CBasePlayerVData", "m_flLegDamageMultiplier");
+
+	// m_flHoldBreathTime
+	[SchemaMember("CBasePlayerVData", "m_flHoldBreathTime")]
+	public ref float HoldBreathTime => ref Schema.GetRef<float>(this.Handle, "CBasePlayerVData", "m_flHoldBreathTime");
+
+	// m_flDrowningDamageInterval
+	[SchemaMember("CBasePlayerVData", "m_flDrowningDamageInterval")]
+	public ref float DrowningDamageInterval => ref Schema.GetRef<float>(this.Handle, "CBasePlayerVData", "m_flDrowningDamageInterval");
+
+	// m_nDrowningDamageInitial
+	[SchemaMember("CBasePlayerVData", "m_nDrowningDamageInitial")]
+	public ref Int32 DrowningDamageInitial => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerVData", "m_nDrowningDamageInitial");
+
+	// m_nDrowningDamageMax
+	[SchemaMember("CBasePlayerVData", "m_nDrowningDamageMax")]
+	public ref Int32 DrowningDamageMax => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerVData", "m_nDrowningDamageMax");
+
+	// m_nWaterSpeed
+	[SchemaMember("CBasePlayerVData", "m_nWaterSpeed")]
+	public ref Int32 WaterSpeed => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerVData", "m_nWaterSpeed");
+
+	// m_flUseRange
+	[SchemaMember("CBasePlayerVData", "m_flUseRange")]
+	public ref float UseRange => ref Schema.GetRef<float>(this.Handle, "CBasePlayerVData", "m_flUseRange");
+
+	// m_flUseAngleTolerance
+	[SchemaMember("CBasePlayerVData", "m_flUseAngleTolerance")]
+	public ref float UseAngleTolerance => ref Schema.GetRef<float>(this.Handle, "CBasePlayerVData", "m_flUseAngleTolerance");
+
+	// m_flCrouchTime
+	[SchemaMember("CBasePlayerVData", "m_flCrouchTime")]
+	public ref float CrouchTime => ref Schema.GetRef<float>(this.Handle, "CBasePlayerVData", "m_flCrouchTime");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBasePlayerWeapon.g.cs

@@ -0,0 +1,53 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBasePlayerWeapon : CEconEntity
+{
+    public CBasePlayerWeapon (IntPtr pointer) : base(pointer) {}
+
+	// m_nNextPrimaryAttackTick
+	[SchemaMember("CBasePlayerWeapon", "m_nNextPrimaryAttackTick")]
+	public ref Int32 NextPrimaryAttackTick => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerWeapon", "m_nNextPrimaryAttackTick");
+
+	// m_flNextPrimaryAttackTickRatio
+	[SchemaMember("CBasePlayerWeapon", "m_flNextPrimaryAttackTickRatio")]
+	public ref float NextPrimaryAttackTickRatio => ref Schema.GetRef<float>(this.Handle, "CBasePlayerWeapon", "m_flNextPrimaryAttackTickRatio");
+
+	// m_nNextSecondaryAttackTick
+	[SchemaMember("CBasePlayerWeapon", "m_nNextSecondaryAttackTick")]
+	public ref Int32 NextSecondaryAttackTick => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerWeapon", "m_nNextSecondaryAttackTick");
+
+	// m_flNextSecondaryAttackTickRatio
+	[SchemaMember("CBasePlayerWeapon", "m_flNextSecondaryAttackTickRatio")]
+	public ref float NextSecondaryAttackTickRatio => ref Schema.GetRef<float>(this.Handle, "CBasePlayerWeapon", "m_flNextSecondaryAttackTickRatio");
+
+	// m_iClip1
+	[SchemaMember("CBasePlayerWeapon", "m_iClip1")]
+	public ref Int32 Clip1 => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerWeapon", "m_iClip1");
+
+	// m_iClip2
+	[SchemaMember("CBasePlayerWeapon", "m_iClip2")]
+	public ref Int32 Clip2 => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerWeapon", "m_iClip2");
+
+	// m_pReserveAmmo
+	[SchemaMember("CBasePlayerWeapon", "m_pReserveAmmo")]
+	public Span<Int32> ReserveAmmo => Schema.GetFixedArray<Int32>(this.Handle, "CBasePlayerWeapon", "m_pReserveAmmo", 2);
+
+	// m_OnPlayerUse
+	[SchemaMember("CBasePlayerWeapon", "m_OnPlayerUse")]
+	public CEntityIOOutput OnPlayerUse => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBasePlayerWeapon", "m_OnPlayerUse");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBasePlayerWeaponVData.g.cs

@@ -0,0 +1,93 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBasePlayerWeaponVData : CEntitySubclassVDataBase
+{
+    public CBasePlayerWeaponVData (IntPtr pointer) : base(pointer) {}
+
+	// m_bBuiltRightHanded
+	[SchemaMember("CBasePlayerWeaponVData", "m_bBuiltRightHanded")]
+	public ref bool BuiltRightHanded => ref Schema.GetRef<bool>(this.Handle, "CBasePlayerWeaponVData", "m_bBuiltRightHanded");
+
+	// m_bAllowFlipping
+	[SchemaMember("CBasePlayerWeaponVData", "m_bAllowFlipping")]
+	public ref bool AllowFlipping => ref Schema.GetRef<bool>(this.Handle, "CBasePlayerWeaponVData", "m_bAllowFlipping");
+
+	// m_sMuzzleAttachment
+	[SchemaMember("CBasePlayerWeaponVData", "m_sMuzzleAttachment")]
+	public string MuzzleAttachment
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBasePlayerWeaponVData", "m_sMuzzleAttachment"); }
+		set { Schema.SetString(this.Handle, "CBasePlayerWeaponVData", "m_sMuzzleAttachment", value); }
+	}
+
+	// m_iFlags
+	[SchemaMember("CBasePlayerWeaponVData", "m_iFlags")]
+	public ref ItemFlagTypes_t Flags => ref Schema.GetRef<ItemFlagTypes_t>(this.Handle, "CBasePlayerWeaponVData", "m_iFlags");
+
+	// m_nPrimaryAmmoType
+	[SchemaMember("CBasePlayerWeaponVData", "m_nPrimaryAmmoType")]
+	public ref byte PrimaryAmmoType => ref Schema.GetRef<byte>(this.Handle, "CBasePlayerWeaponVData", "m_nPrimaryAmmoType");
+
+	// m_nSecondaryAmmoType
+	[SchemaMember("CBasePlayerWeaponVData", "m_nSecondaryAmmoType")]
+	public ref byte SecondaryAmmoType => ref Schema.GetRef<byte>(this.Handle, "CBasePlayerWeaponVData", "m_nSecondaryAmmoType");
+
+	// m_iMaxClip1
+	[SchemaMember("CBasePlayerWeaponVData", "m_iMaxClip1")]
+	public ref Int32 MaxClip1 => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerWeaponVData", "m_iMaxClip1");
+
+	// m_iMaxClip2
+	[SchemaMember("CBasePlayerWeaponVData", "m_iMaxClip2")]
+	public ref Int32 MaxClip2 => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerWeaponVData", "m_iMaxClip2");
+
+	// m_iDefaultClip1
+	[SchemaMember("CBasePlayerWeaponVData", "m_iDefaultClip1")]
+	public ref Int32 DefaultClip1 => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerWeaponVData", "m_iDefaultClip1");
+
+	// m_iDefaultClip2
+	[SchemaMember("CBasePlayerWeaponVData", "m_iDefaultClip2")]
+	public ref Int32 DefaultClip2 => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerWeaponVData", "m_iDefaultClip2");
+
+	// m_iWeight
+	[SchemaMember("CBasePlayerWeaponVData", "m_iWeight")]
+	public ref Int32 Weight => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerWeaponVData", "m_iWeight");
+
+	// m_bAutoSwitchTo
+	[SchemaMember("CBasePlayerWeaponVData", "m_bAutoSwitchTo")]
+	public ref bool AutoSwitchTo => ref Schema.GetRef<bool>(this.Handle, "CBasePlayerWeaponVData", "m_bAutoSwitchTo");
+
+	// m_bAutoSwitchFrom
+	[SchemaMember("CBasePlayerWeaponVData", "m_bAutoSwitchFrom")]
+	public ref bool AutoSwitchFrom => ref Schema.GetRef<bool>(this.Handle, "CBasePlayerWeaponVData", "m_bAutoSwitchFrom");
+
+	// m_iRumbleEffect
+	[SchemaMember("CBasePlayerWeaponVData", "m_iRumbleEffect")]
+	public ref RumbleEffect_t RumbleEffect => ref Schema.GetRef<RumbleEffect_t>(this.Handle, "CBasePlayerWeaponVData", "m_iRumbleEffect");
+
+	// m_bLinkedCooldowns
+	[SchemaMember("CBasePlayerWeaponVData", "m_bLinkedCooldowns")]
+	public ref bool LinkedCooldowns => ref Schema.GetRef<bool>(this.Handle, "CBasePlayerWeaponVData", "m_bLinkedCooldowns");
+
+	// m_iSlot
+	[SchemaMember("CBasePlayerWeaponVData", "m_iSlot")]
+	public ref Int32 Slot => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerWeaponVData", "m_iSlot");
+
+	// m_iPosition
+	[SchemaMember("CBasePlayerWeaponVData", "m_iPosition")]
+	public ref Int32 Position => ref Schema.GetRef<Int32>(this.Handle, "CBasePlayerWeaponVData", "m_iPosition");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseProp.g.cs

@@ -0,0 +1,37 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseProp : CBaseAnimGraph
+{
+    public CBaseProp (IntPtr pointer) : base(pointer) {}
+
+	// m_bModelOverrodeBlockLOS
+	[SchemaMember("CBaseProp", "m_bModelOverrodeBlockLOS")]
+	public ref bool ModelOverrodeBlockLOS => ref Schema.GetRef<bool>(this.Handle, "CBaseProp", "m_bModelOverrodeBlockLOS");
+
+	// m_iShapeType
+	[SchemaMember("CBaseProp", "m_iShapeType")]
+	public ref Int32 ShapeType => ref Schema.GetRef<Int32>(this.Handle, "CBaseProp", "m_iShapeType");
+
+	// m_bConformToCollisionBounds
+	[SchemaMember("CBaseProp", "m_bConformToCollisionBounds")]
+	public ref bool ConformToCollisionBounds => ref Schema.GetRef<bool>(this.Handle, "CBaseProp", "m_bConformToCollisionBounds");
+
+	// m_mPreferredCatchTransform
+	[SchemaMember("CBaseProp", "m_mPreferredCatchTransform")]
+	public matrix3x4_t MPreferredCatchTransform => Schema.GetDeclaredClass<matrix3x4_t>(this.Handle, "CBaseProp", "m_mPreferredCatchTransform");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBasePropDoor.g.cs

@@ -0,0 +1,209 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBasePropDoor : CDynamicProp
+{
+    public CBasePropDoor (IntPtr pointer) : base(pointer) {}
+
+	// m_flAutoReturnDelay
+	[SchemaMember("CBasePropDoor", "m_flAutoReturnDelay")]
+	public ref float AutoReturnDelay => ref Schema.GetRef<float>(this.Handle, "CBasePropDoor", "m_flAutoReturnDelay");
+
+	// m_hDoorList
+	[SchemaMember("CBasePropDoor", "m_hDoorList")]
+	public NetworkedVector<CHandle<CBasePropDoor>> DoorList => Schema.GetDeclaredClass<NetworkedVector<CHandle<CBasePropDoor>>>(this.Handle, "CBasePropDoor", "m_hDoorList");
+
+	// m_nHardwareType
+	[SchemaMember("CBasePropDoor", "m_nHardwareType")]
+	public ref Int32 HardwareType => ref Schema.GetRef<Int32>(this.Handle, "CBasePropDoor", "m_nHardwareType");
+
+	// m_bNeedsHardware
+	[SchemaMember("CBasePropDoor", "m_bNeedsHardware")]
+	public ref bool NeedsHardware => ref Schema.GetRef<bool>(this.Handle, "CBasePropDoor", "m_bNeedsHardware");
+
+	// m_eDoorState
+	[SchemaMember("CBasePropDoor", "m_eDoorState")]
+	public ref DoorState_t DoorState => ref Schema.GetRef<DoorState_t>(this.Handle, "CBasePropDoor", "m_eDoorState");
+
+	// m_bLocked
+	[SchemaMember("CBasePropDoor", "m_bLocked")]
+	public ref bool Locked => ref Schema.GetRef<bool>(this.Handle, "CBasePropDoor", "m_bLocked");
+
+	// m_closedPosition
+	[SchemaMember("CBasePropDoor", "m_closedPosition")]
+	public Vector ClosedPosition => Schema.GetDeclaredClass<Vector>(this.Handle, "CBasePropDoor", "m_closedPosition");
+
+	// m_closedAngles
+	[SchemaMember("CBasePropDoor", "m_closedAngles")]
+	public QAngle ClosedAngles => Schema.GetDeclaredClass<QAngle>(this.Handle, "CBasePropDoor", "m_closedAngles");
+
+	// m_hBlocker
+	[SchemaMember("CBasePropDoor", "m_hBlocker")]
+	public CHandle<CBaseEntity> Blocker => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CBasePropDoor", "m_hBlocker");
+
+	// m_bFirstBlocked
+	[SchemaMember("CBasePropDoor", "m_bFirstBlocked")]
+	public ref bool FirstBlocked => ref Schema.GetRef<bool>(this.Handle, "CBasePropDoor", "m_bFirstBlocked");
+
+	// m_ls
+	[SchemaMember("CBasePropDoor", "m_ls")]
+	public locksound_t Ls => Schema.GetDeclaredClass<locksound_t>(this.Handle, "CBasePropDoor", "m_ls");
+
+	// m_bForceClosed
+	[SchemaMember("CBasePropDoor", "m_bForceClosed")]
+	public ref bool ForceClosed => ref Schema.GetRef<bool>(this.Handle, "CBasePropDoor", "m_bForceClosed");
+
+	// m_vecLatchWorldPosition
+	[SchemaMember("CBasePropDoor", "m_vecLatchWorldPosition")]
+	public Vector LatchWorldPosition => Schema.GetDeclaredClass<Vector>(this.Handle, "CBasePropDoor", "m_vecLatchWorldPosition");
+
+	// m_hActivator
+	[SchemaMember("CBasePropDoor", "m_hActivator")]
+	public CHandle<CBaseEntity> Activator => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CBasePropDoor", "m_hActivator");
+
+	// m_SoundMoving
+	[SchemaMember("CBasePropDoor", "m_SoundMoving")]
+	public string SoundMoving
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBasePropDoor", "m_SoundMoving"); }
+		set { Schema.SetString(this.Handle, "CBasePropDoor", "m_SoundMoving", value); }
+	}
+
+	// m_SoundOpen
+	[SchemaMember("CBasePropDoor", "m_SoundOpen")]
+	public string SoundOpen
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBasePropDoor", "m_SoundOpen"); }
+		set { Schema.SetString(this.Handle, "CBasePropDoor", "m_SoundOpen", value); }
+	}
+
+	// m_SoundClose
+	[SchemaMember("CBasePropDoor", "m_SoundClose")]
+	public string SoundClose
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBasePropDoor", "m_SoundClose"); }
+		set { Schema.SetString(this.Handle, "CBasePropDoor", "m_SoundClose", value); }
+	}
+
+	// m_SoundLock
+	[SchemaMember("CBasePropDoor", "m_SoundLock")]
+	public string SoundLock
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBasePropDoor", "m_SoundLock"); }
+		set { Schema.SetString(this.Handle, "CBasePropDoor", "m_SoundLock", value); }
+	}
+
+	// m_SoundUnlock
+	[SchemaMember("CBasePropDoor", "m_SoundUnlock")]
+	public string SoundUnlock
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBasePropDoor", "m_SoundUnlock"); }
+		set { Schema.SetString(this.Handle, "CBasePropDoor", "m_SoundUnlock", value); }
+	}
+
+	// m_SoundLatch
+	[SchemaMember("CBasePropDoor", "m_SoundLatch")]
+	public string SoundLatch
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBasePropDoor", "m_SoundLatch"); }
+		set { Schema.SetString(this.Handle, "CBasePropDoor", "m_SoundLatch", value); }
+	}
+
+	// m_SoundPound
+	[SchemaMember("CBasePropDoor", "m_SoundPound")]
+	public string SoundPound
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBasePropDoor", "m_SoundPound"); }
+		set { Schema.SetString(this.Handle, "CBasePropDoor", "m_SoundPound", value); }
+	}
+
+	// m_SoundJiggle
+	[SchemaMember("CBasePropDoor", "m_SoundJiggle")]
+	public string SoundJiggle
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBasePropDoor", "m_SoundJiggle"); }
+		set { Schema.SetString(this.Handle, "CBasePropDoor", "m_SoundJiggle", value); }
+	}
+
+	// m_SoundLockedAnim
+	[SchemaMember("CBasePropDoor", "m_SoundLockedAnim")]
+	public string SoundLockedAnim
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBasePropDoor", "m_SoundLockedAnim"); }
+		set { Schema.SetString(this.Handle, "CBasePropDoor", "m_SoundLockedAnim", value); }
+	}
+
+	// m_numCloseAttempts
+	[SchemaMember("CBasePropDoor", "m_numCloseAttempts")]
+	public ref Int32 NumCloseAttempts => ref Schema.GetRef<Int32>(this.Handle, "CBasePropDoor", "m_numCloseAttempts");
+
+	// m_nPhysicsMaterial
+	[SchemaMember("CBasePropDoor", "m_nPhysicsMaterial")]
+	public CUtlStringToken PhysicsMaterial => Schema.GetDeclaredClass<CUtlStringToken>(this.Handle, "CBasePropDoor", "m_nPhysicsMaterial");
+
+	// m_SlaveName
+	[SchemaMember("CBasePropDoor", "m_SlaveName")]
+	public string SlaveName
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBasePropDoor", "m_SlaveName"); }
+		set { Schema.SetString(this.Handle, "CBasePropDoor", "m_SlaveName", value); }
+	}
+
+	// m_hMaster
+	[SchemaMember("CBasePropDoor", "m_hMaster")]
+	public CHandle<CBasePropDoor> Master => Schema.GetDeclaredClass<CHandle<CBasePropDoor>>(this.Handle, "CBasePropDoor", "m_hMaster");
+
+	// m_OnBlockedClosing
+	[SchemaMember("CBasePropDoor", "m_OnBlockedClosing")]
+	public CEntityIOOutput OnBlockedClosing => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBasePropDoor", "m_OnBlockedClosing");
+
+	// m_OnBlockedOpening
+	[SchemaMember("CBasePropDoor", "m_OnBlockedOpening")]
+	public CEntityIOOutput OnBlockedOpening => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBasePropDoor", "m_OnBlockedOpening");
+
+	// m_OnUnblockedClosing
+	[SchemaMember("CBasePropDoor", "m_OnUnblockedClosing")]
+	public CEntityIOOutput OnUnblockedClosing => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBasePropDoor", "m_OnUnblockedClosing");
+
+	// m_OnUnblockedOpening
+	[SchemaMember("CBasePropDoor", "m_OnUnblockedOpening")]
+	public CEntityIOOutput OnUnblockedOpening => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBasePropDoor", "m_OnUnblockedOpening");
+
+	// m_OnFullyClosed
+	[SchemaMember("CBasePropDoor", "m_OnFullyClosed")]
+	public CEntityIOOutput OnFullyClosed => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBasePropDoor", "m_OnFullyClosed");
+
+	// m_OnFullyOpen
+	[SchemaMember("CBasePropDoor", "m_OnFullyOpen")]
+	public CEntityIOOutput OnFullyOpen => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBasePropDoor", "m_OnFullyOpen");
+
+	// m_OnClose
+	[SchemaMember("CBasePropDoor", "m_OnClose")]
+	public CEntityIOOutput OnClose => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBasePropDoor", "m_OnClose");
+
+	// m_OnOpen
+	[SchemaMember("CBasePropDoor", "m_OnOpen")]
+	public CEntityIOOutput OnOpen => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBasePropDoor", "m_OnOpen");
+
+	// m_OnLockedUse
+	[SchemaMember("CBasePropDoor", "m_OnLockedUse")]
+	public CEntityIOOutput OnLockedUse => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBasePropDoor", "m_OnLockedUse");
+
+	// m_OnAjarOpen
+	[SchemaMember("CBasePropDoor", "m_OnAjarOpen")]
+	public CEntityIOOutput OnAjarOpen => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBasePropDoor", "m_OnAjarOpen");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseToggle.g.cs

@@ -0,0 +1,89 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseToggle : CBaseModelEntity
+{
+    public CBaseToggle (IntPtr pointer) : base(pointer) {}
+
+	// m_toggle_state
+	[SchemaMember("CBaseToggle", "m_toggle_state")]
+	public ref TOGGLE_STATE Toggle_state => ref Schema.GetRef<TOGGLE_STATE>(this.Handle, "CBaseToggle", "m_toggle_state");
+
+	// m_flMoveDistance
+	[SchemaMember("CBaseToggle", "m_flMoveDistance")]
+	public ref float MoveDistance => ref Schema.GetRef<float>(this.Handle, "CBaseToggle", "m_flMoveDistance");
+
+	// m_flWait
+	[SchemaMember("CBaseToggle", "m_flWait")]
+	public ref float Wait => ref Schema.GetRef<float>(this.Handle, "CBaseToggle", "m_flWait");
+
+	// m_flLip
+	[SchemaMember("CBaseToggle", "m_flLip")]
+	public ref float Lip => ref Schema.GetRef<float>(this.Handle, "CBaseToggle", "m_flLip");
+
+	// m_bAlwaysFireBlockedOutputs
+	[SchemaMember("CBaseToggle", "m_bAlwaysFireBlockedOutputs")]
+	public ref bool AlwaysFireBlockedOutputs => ref Schema.GetRef<bool>(this.Handle, "CBaseToggle", "m_bAlwaysFireBlockedOutputs");
+
+	// m_vecPosition1
+	[SchemaMember("CBaseToggle", "m_vecPosition1")]
+	public Vector Position1 => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseToggle", "m_vecPosition1");
+
+	// m_vecPosition2
+	[SchemaMember("CBaseToggle", "m_vecPosition2")]
+	public Vector Position2 => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseToggle", "m_vecPosition2");
+
+	// m_vecMoveAng
+	[SchemaMember("CBaseToggle", "m_vecMoveAng")]
+	public QAngle MoveAng => Schema.GetDeclaredClass<QAngle>(this.Handle, "CBaseToggle", "m_vecMoveAng");
+
+	// m_vecAngle1
+	[SchemaMember("CBaseToggle", "m_vecAngle1")]
+	public QAngle Angle1 => Schema.GetDeclaredClass<QAngle>(this.Handle, "CBaseToggle", "m_vecAngle1");
+
+	// m_vecAngle2
+	[SchemaMember("CBaseToggle", "m_vecAngle2")]
+	public QAngle Angle2 => Schema.GetDeclaredClass<QAngle>(this.Handle, "CBaseToggle", "m_vecAngle2");
+
+	// m_flHeight
+	[SchemaMember("CBaseToggle", "m_flHeight")]
+	public ref float Height => ref Schema.GetRef<float>(this.Handle, "CBaseToggle", "m_flHeight");
+
+	// m_hActivator
+	[SchemaMember("CBaseToggle", "m_hActivator")]
+	public CHandle<CBaseEntity> Activator => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CBaseToggle", "m_hActivator");
+
+	// m_vecFinalDest
+	[SchemaMember("CBaseToggle", "m_vecFinalDest")]
+	public Vector FinalDest => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseToggle", "m_vecFinalDest");
+
+	// m_vecFinalAngle
+	[SchemaMember("CBaseToggle", "m_vecFinalAngle")]
+	public QAngle FinalAngle => Schema.GetDeclaredClass<QAngle>(this.Handle, "CBaseToggle", "m_vecFinalAngle");
+
+	// m_movementType
+	[SchemaMember("CBaseToggle", "m_movementType")]
+	public ref Int32 MovementType => ref Schema.GetRef<Int32>(this.Handle, "CBaseToggle", "m_movementType");
+
+	// m_sMaster
+	[SchemaMember("CBaseToggle", "m_sMaster")]
+	public string Master
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseToggle", "m_sMaster"); }
+		set { Schema.SetString(this.Handle, "CBaseToggle", "m_sMaster", value); }
+	}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseTrigger.g.cs

@@ -0,0 +1,69 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseTrigger : CBaseToggle
+{
+    public CBaseTrigger (IntPtr pointer) : base(pointer) {}
+
+	// m_bDisabled
+	[SchemaMember("CBaseTrigger", "m_bDisabled")]
+	public ref bool Disabled => ref Schema.GetRef<bool>(this.Handle, "CBaseTrigger", "m_bDisabled");
+
+	// m_iFilterName
+	[SchemaMember("CBaseTrigger", "m_iFilterName")]
+	public string FilterName
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseTrigger", "m_iFilterName"); }
+		set { Schema.SetString(this.Handle, "CBaseTrigger", "m_iFilterName", value); }
+	}
+
+	// m_hFilter
+	[SchemaMember("CBaseTrigger", "m_hFilter")]
+	public CHandle<CBaseFilter> Filter => Schema.GetDeclaredClass<CHandle<CBaseFilter>>(this.Handle, "CBaseTrigger", "m_hFilter");
+
+	// m_OnStartTouch
+	[SchemaMember("CBaseTrigger", "m_OnStartTouch")]
+	public CEntityIOOutput OnStartTouch => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseTrigger", "m_OnStartTouch");
+
+	// m_OnStartTouchAll
+	[SchemaMember("CBaseTrigger", "m_OnStartTouchAll")]
+	public CEntityIOOutput OnStartTouchAll => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseTrigger", "m_OnStartTouchAll");
+
+	// m_OnEndTouch
+	[SchemaMember("CBaseTrigger", "m_OnEndTouch")]
+	public CEntityIOOutput OnEndTouch => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseTrigger", "m_OnEndTouch");
+
+	// m_OnEndTouchAll
+	[SchemaMember("CBaseTrigger", "m_OnEndTouchAll")]
+	public CEntityIOOutput OnEndTouchAll => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseTrigger", "m_OnEndTouchAll");
+
+	// m_OnTouching
+	[SchemaMember("CBaseTrigger", "m_OnTouching")]
+	public CEntityIOOutput OnTouching => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseTrigger", "m_OnTouching");
+
+	// m_OnNotTouching
+	[SchemaMember("CBaseTrigger", "m_OnNotTouching")]
+	public CEntityIOOutput OnNotTouching => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBaseTrigger", "m_OnNotTouching");
+
+	// m_hTouchingEntities
+	[SchemaMember("CBaseTrigger", "m_hTouchingEntities")]
+	public NetworkedVector<CHandle<CBaseEntity>> TouchingEntities => Schema.GetDeclaredClass<NetworkedVector<CHandle<CBaseEntity>>>(this.Handle, "CBaseTrigger", "m_hTouchingEntities");
+
+	// m_bClientSidePredicted
+	[SchemaMember("CBaseTrigger", "m_bClientSidePredicted")]
+	public ref bool ClientSidePredicted => ref Schema.GetRef<bool>(this.Handle, "CBaseTrigger", "m_bClientSidePredicted");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseViewModel.g.cs

@@ -0,0 +1,73 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBaseViewModel : CBaseAnimGraph
+{
+    public CBaseViewModel (IntPtr pointer) : base(pointer) {}
+
+	// m_vecLastFacing
+	[SchemaMember("CBaseViewModel", "m_vecLastFacing")]
+	public Vector LastFacing => Schema.GetDeclaredClass<Vector>(this.Handle, "CBaseViewModel", "m_vecLastFacing");
+
+	// m_nViewModelIndex
+	[SchemaMember("CBaseViewModel", "m_nViewModelIndex")]
+	public ref UInt32 ViewModelIndex => ref Schema.GetRef<UInt32>(this.Handle, "CBaseViewModel", "m_nViewModelIndex");
+
+	// m_nAnimationParity
+	[SchemaMember("CBaseViewModel", "m_nAnimationParity")]
+	public ref UInt32 AnimationParity => ref Schema.GetRef<UInt32>(this.Handle, "CBaseViewModel", "m_nAnimationParity");
+
+	// m_flAnimationStartTime
+	[SchemaMember("CBaseViewModel", "m_flAnimationStartTime")]
+	public ref float AnimationStartTime => ref Schema.GetRef<float>(this.Handle, "CBaseViewModel", "m_flAnimationStartTime");
+
+	// m_hWeapon
+	[SchemaMember("CBaseViewModel", "m_hWeapon")]
+	public CHandle<CBasePlayerWeapon> Weapon => Schema.GetDeclaredClass<CHandle<CBasePlayerWeapon>>(this.Handle, "CBaseViewModel", "m_hWeapon");
+
+	// m_sVMName
+	[SchemaMember("CBaseViewModel", "m_sVMName")]
+	public string VMName
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseViewModel", "m_sVMName"); }
+		set { Schema.SetString(this.Handle, "CBaseViewModel", "m_sVMName", value); }
+	}
+
+	// m_sAnimationPrefix
+	[SchemaMember("CBaseViewModel", "m_sAnimationPrefix")]
+	public string AnimationPrefix
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBaseViewModel", "m_sAnimationPrefix"); }
+		set { Schema.SetString(this.Handle, "CBaseViewModel", "m_sAnimationPrefix", value); }
+	}
+
+	// m_hOldLayerSequence
+	[SchemaMember("CBaseViewModel", "m_hOldLayerSequence")]
+	public ref Int32 OldLayerSequence => ref Schema.GetRef<Int32>(this.Handle, "CBaseViewModel", "m_hOldLayerSequence");
+
+	// m_oldLayer
+	[SchemaMember("CBaseViewModel", "m_oldLayer")]
+	public ref Int32 OldLayer => ref Schema.GetRef<Int32>(this.Handle, "CBaseViewModel", "m_oldLayer");
+
+	// m_oldLayerStartTime
+	[SchemaMember("CBaseViewModel", "m_oldLayerStartTime")]
+	public ref float OldLayerStartTime => ref Schema.GetRef<float>(this.Handle, "CBaseViewModel", "m_oldLayerStartTime");
+
+	// m_hControlPanel
+	[SchemaMember("CBaseViewModel", "m_hControlPanel")]
+	public CHandle<CBaseEntity> ControlPanel => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CBaseViewModel", "m_hControlPanel");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBeam.g.cs

@@ -0,0 +1,117 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBeam : CBaseModelEntity
+{
+    public CBeam (IntPtr pointer) : base(pointer) {}
+
+	// m_flFrameRate
+	[SchemaMember("CBeam", "m_flFrameRate")]
+	public ref float FrameRate => ref Schema.GetRef<float>(this.Handle, "CBeam", "m_flFrameRate");
+
+	// m_flHDRColorScale
+	[SchemaMember("CBeam", "m_flHDRColorScale")]
+	public ref float HDRColorScale => ref Schema.GetRef<float>(this.Handle, "CBeam", "m_flHDRColorScale");
+
+	// m_flFireTime
+	[SchemaMember("CBeam", "m_flFireTime")]
+	public ref float FireTime => ref Schema.GetRef<float>(this.Handle, "CBeam", "m_flFireTime");
+
+	// m_flDamage
+	[SchemaMember("CBeam", "m_flDamage")]
+	public ref float Damage => ref Schema.GetRef<float>(this.Handle, "CBeam", "m_flDamage");
+
+	// m_nNumBeamEnts
+	[SchemaMember("CBeam", "m_nNumBeamEnts")]
+	public ref byte NumBeamEnts => ref Schema.GetRef<byte>(this.Handle, "CBeam", "m_nNumBeamEnts");
+
+	// m_hBaseMaterial
+	[SchemaMember("CBeam", "m_hBaseMaterial")]
+	public CStrongHandle<InfoForResourceTypeIMaterial2> BaseMaterial => Schema.GetDeclaredClass<CStrongHandle<InfoForResourceTypeIMaterial2>>(this.Handle, "CBeam", "m_hBaseMaterial");
+
+	// m_nHaloIndex
+	[SchemaMember("CBeam", "m_nHaloIndex")]
+	public CStrongHandle<InfoForResourceTypeIMaterial2> HaloIndex => Schema.GetDeclaredClass<CStrongHandle<InfoForResourceTypeIMaterial2>>(this.Handle, "CBeam", "m_nHaloIndex");
+
+	// m_nBeamType
+	[SchemaMember("CBeam", "m_nBeamType")]
+	public ref BeamType_t BeamType => ref Schema.GetRef<BeamType_t>(this.Handle, "CBeam", "m_nBeamType");
+
+	// m_nBeamFlags
+	[SchemaMember("CBeam", "m_nBeamFlags")]
+	public ref UInt32 BeamFlags => ref Schema.GetRef<UInt32>(this.Handle, "CBeam", "m_nBeamFlags");
+
+	// m_hAttachEntity
+	[SchemaMember("CBeam", "m_hAttachEntity")]
+	public Span<CHandle<CBaseEntity>> AttachEntity => Schema.GetFixedArray<CHandle<CBaseEntity>>(this.Handle, "CBeam", "m_hAttachEntity", 10);
+
+	// m_nAttachIndex
+	[SchemaMember("CBeam", "m_nAttachIndex")]
+	public Span<AttachmentHandle_t> AttachIndex => Schema.GetFixedArray<AttachmentHandle_t>(this.Handle, "CBeam", "m_nAttachIndex", 10);
+
+	// m_fWidth
+	[SchemaMember("CBeam", "m_fWidth")]
+	public ref float Width => ref Schema.GetRef<float>(this.Handle, "CBeam", "m_fWidth");
+
+	// m_fEndWidth
+	[SchemaMember("CBeam", "m_fEndWidth")]
+	public ref float EndWidth => ref Schema.GetRef<float>(this.Handle, "CBeam", "m_fEndWidth");
+
+	// m_fFadeLength
+	[SchemaMember("CBeam", "m_fFadeLength")]
+	public ref float FadeLength => ref Schema.GetRef<float>(this.Handle, "CBeam", "m_fFadeLength");
+
+	// m_fHaloScale
+	[SchemaMember("CBeam", "m_fHaloScale")]
+	public ref float HaloScale => ref Schema.GetRef<float>(this.Handle, "CBeam", "m_fHaloScale");
+
+	// m_fAmplitude
+	[SchemaMember("CBeam", "m_fAmplitude")]
+	public ref float Amplitude => ref Schema.GetRef<float>(this.Handle, "CBeam", "m_fAmplitude");
+
+	// m_fStartFrame
+	[SchemaMember("CBeam", "m_fStartFrame")]
+	public ref float StartFrame => ref Schema.GetRef<float>(this.Handle, "CBeam", "m_fStartFrame");
+
+	// m_fSpeed
+	[SchemaMember("CBeam", "m_fSpeed")]
+	public ref float Speed => ref Schema.GetRef<float>(this.Handle, "CBeam", "m_fSpeed");
+
+	// m_flFrame
+	[SchemaMember("CBeam", "m_flFrame")]
+	public ref float Frame => ref Schema.GetRef<float>(this.Handle, "CBeam", "m_flFrame");
+
+	// m_nClipStyle
+	[SchemaMember("CBeam", "m_nClipStyle")]
+	public ref BeamClipStyle_t ClipStyle => ref Schema.GetRef<BeamClipStyle_t>(this.Handle, "CBeam", "m_nClipStyle");
+
+	// m_bTurnedOff
+	[SchemaMember("CBeam", "m_bTurnedOff")]
+	public ref bool TurnedOff => ref Schema.GetRef<bool>(this.Handle, "CBeam", "m_bTurnedOff");
+
+	// m_vecEndPos
+	[SchemaMember("CBeam", "m_vecEndPos")]
+	public Vector EndPos => Schema.GetDeclaredClass<Vector>(this.Handle, "CBeam", "m_vecEndPos");
+
+	// m_hEndEntity
+	[SchemaMember("CBeam", "m_hEndEntity")]
+	public CHandle<CBaseEntity> EndEntity => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CBeam", "m_hEndEntity");
+
+	// m_nDissolveType
+	[SchemaMember("CBeam", "m_nDissolveType")]
+	public ref Int32 DissolveType => ref Schema.GetRef<Int32>(this.Handle, "CBeam", "m_nDissolveType");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBlood.g.cs

@@ -0,0 +1,37 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBlood : CPointEntity
+{
+    public CBlood (IntPtr pointer) : base(pointer) {}
+
+	// m_vecSprayAngles
+	[SchemaMember("CBlood", "m_vecSprayAngles")]
+	public QAngle SprayAngles => Schema.GetDeclaredClass<QAngle>(this.Handle, "CBlood", "m_vecSprayAngles");
+
+	// m_vecSprayDir
+	[SchemaMember("CBlood", "m_vecSprayDir")]
+	public Vector SprayDir => Schema.GetDeclaredClass<Vector>(this.Handle, "CBlood", "m_vecSprayDir");
+
+	// m_flAmount
+	[SchemaMember("CBlood", "m_flAmount")]
+	public ref float Amount => ref Schema.GetRef<float>(this.Handle, "CBlood", "m_flAmount");
+
+	// m_Color
+	[SchemaMember("CBlood", "m_Color")]
+	public ref Int32 Color => ref Schema.GetRef<Int32>(this.Handle, "CBlood", "m_Color");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBodyComponent.g.cs

@@ -0,0 +1,29 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBodyComponent : CEntityComponent
+{
+    public CBodyComponent (IntPtr pointer) : base(pointer) {}
+
+	// m_pSceneNode
+	[SchemaMember("CBodyComponent", "m_pSceneNode")]
+	public CGameSceneNode? SceneNode => Schema.GetPointer<CGameSceneNode>(this.Handle, "CBodyComponent", "m_pSceneNode");
+
+	// __m_pChainEntity
+	[SchemaMember("CBodyComponent", "__m_pChainEntity")]
+	public CNetworkVarChainer __m_pChainEntity => Schema.GetDeclaredClass<CNetworkVarChainer>(this.Handle, "CBodyComponent", "__m_pChainEntity");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBodyComponentBaseAnimGraph.g.cs

@@ -0,0 +1,29 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBodyComponentBaseAnimGraph : CBodyComponentSkeletonInstance
+{
+    public CBodyComponentBaseAnimGraph (IntPtr pointer) : base(pointer) {}
+
+	// m_animationController
+	[SchemaMember("CBodyComponentBaseAnimGraph", "m_animationController")]
+	public CBaseAnimGraphController AnimationController => Schema.GetDeclaredClass<CBaseAnimGraphController>(this.Handle, "CBodyComponentBaseAnimGraph", "m_animationController");
+
+	// __m_pChainEntity
+	[SchemaMember("CBodyComponentBaseAnimGraph", "__m_pChainEntity")]
+	public CNetworkVarChainer __m_pChainEntity => Schema.GetDeclaredClass<CNetworkVarChainer>(this.Handle, "CBodyComponentBaseAnimGraph", "__m_pChainEntity");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBodyComponentBaseModelEntity.g.cs

@@ -0,0 +1,25 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBodyComponentBaseModelEntity : CBodyComponentSkeletonInstance
+{
+    public CBodyComponentBaseModelEntity (IntPtr pointer) : base(pointer) {}
+
+	// __m_pChainEntity
+	[SchemaMember("CBodyComponentBaseModelEntity", "__m_pChainEntity")]
+	public CNetworkVarChainer __m_pChainEntity => Schema.GetDeclaredClass<CNetworkVarChainer>(this.Handle, "CBodyComponentBaseModelEntity", "__m_pChainEntity");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBodyComponentPoint.g.cs

@@ -0,0 +1,29 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBodyComponentPoint : CBodyComponent
+{
+    public CBodyComponentPoint (IntPtr pointer) : base(pointer) {}
+
+	// m_sceneNode
+	[SchemaMember("CBodyComponentPoint", "m_sceneNode")]
+	public CGameSceneNode SceneNode => Schema.GetDeclaredClass<CGameSceneNode>(this.Handle, "CBodyComponentPoint", "m_sceneNode");
+
+	// __m_pChainEntity
+	[SchemaMember("CBodyComponentPoint", "__m_pChainEntity")]
+	public CNetworkVarChainer __m_pChainEntity => Schema.GetDeclaredClass<CNetworkVarChainer>(this.Handle, "CBodyComponentPoint", "__m_pChainEntity");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBodyComponentSkeletonInstance.g.cs

@@ -0,0 +1,29 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBodyComponentSkeletonInstance : CBodyComponent
+{
+    public CBodyComponentSkeletonInstance (IntPtr pointer) : base(pointer) {}
+
+	// m_skeletonInstance
+	[SchemaMember("CBodyComponentSkeletonInstance", "m_skeletonInstance")]
+	public CSkeletonInstance SkeletonInstance => Schema.GetDeclaredClass<CSkeletonInstance>(this.Handle, "CBodyComponentSkeletonInstance", "m_skeletonInstance");
+
+	// __m_pChainEntity
+	[SchemaMember("CBodyComponentSkeletonInstance", "__m_pChainEntity")]
+	public CNetworkVarChainer __m_pChainEntity => Schema.GetDeclaredClass<CNetworkVarChainer>(this.Handle, "CBodyComponentSkeletonInstance", "__m_pChainEntity");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBombTarget.g.cs

@@ -0,0 +1,61 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBombTarget : CBaseTrigger
+{
+    public CBombTarget (IntPtr pointer) : base(pointer) {}
+
+	// m_OnBombExplode
+	[SchemaMember("CBombTarget", "m_OnBombExplode")]
+	public CEntityIOOutput OnBombExplode => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBombTarget", "m_OnBombExplode");
+
+	// m_OnBombPlanted
+	[SchemaMember("CBombTarget", "m_OnBombPlanted")]
+	public CEntityIOOutput OnBombPlanted => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBombTarget", "m_OnBombPlanted");
+
+	// m_OnBombDefused
+	[SchemaMember("CBombTarget", "m_OnBombDefused")]
+	public CEntityIOOutput OnBombDefused => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBombTarget", "m_OnBombDefused");
+
+	// m_bIsBombSiteB
+	[SchemaMember("CBombTarget", "m_bIsBombSiteB")]
+	public ref bool IsBombSiteB => ref Schema.GetRef<bool>(this.Handle, "CBombTarget", "m_bIsBombSiteB");
+
+	// m_bIsHeistBombTarget
+	[SchemaMember("CBombTarget", "m_bIsHeistBombTarget")]
+	public ref bool IsHeistBombTarget => ref Schema.GetRef<bool>(this.Handle, "CBombTarget", "m_bIsHeistBombTarget");
+
+	// m_bBombPlantedHere
+	[SchemaMember("CBombTarget", "m_bBombPlantedHere")]
+	public ref bool BombPlantedHere => ref Schema.GetRef<bool>(this.Handle, "CBombTarget", "m_bBombPlantedHere");
+
+	// m_szMountTarget
+	[SchemaMember("CBombTarget", "m_szMountTarget")]
+	public string MountTarget
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBombTarget", "m_szMountTarget"); }
+		set { Schema.SetString(this.Handle, "CBombTarget", "m_szMountTarget", value); }
+	}
+
+	// m_hInstructorHint
+	[SchemaMember("CBombTarget", "m_hInstructorHint")]
+	public CHandle<CBaseEntity> InstructorHint => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CBombTarget", "m_hInstructorHint");
+
+	// m_nBombSiteDesignation
+	[SchemaMember("CBombTarget", "m_nBombSiteDesignation")]
+	public ref Int32 BombSiteDesignation => ref Schema.GetRef<Int32>(this.Handle, "CBombTarget", "m_nBombSiteDesignation");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBot.g.cs

@@ -0,0 +1,73 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBot : NativeObject
+{
+    public CBot (IntPtr pointer) : base(pointer) {}
+
+	// m_pController
+	[SchemaMember("CBot", "m_pController")]
+	public CCSPlayerController? Controller => Schema.GetPointer<CCSPlayerController>(this.Handle, "CBot", "m_pController");
+
+	// m_pPlayer
+	[SchemaMember("CBot", "m_pPlayer")]
+	public CCSPlayerPawn? Player => Schema.GetPointer<CCSPlayerPawn>(this.Handle, "CBot", "m_pPlayer");
+
+	// m_bHasSpawned
+	[SchemaMember("CBot", "m_bHasSpawned")]
+	public ref bool HasSpawned => ref Schema.GetRef<bool>(this.Handle, "CBot", "m_bHasSpawned");
+
+	// m_id
+	[SchemaMember("CBot", "m_id")]
+	public ref UInt32 Id => ref Schema.GetRef<UInt32>(this.Handle, "CBot", "m_id");
+
+	// m_isRunning
+	[SchemaMember("CBot", "m_isRunning")]
+	public ref bool IsRunning => ref Schema.GetRef<bool>(this.Handle, "CBot", "m_isRunning");
+
+	// m_isCrouching
+	[SchemaMember("CBot", "m_isCrouching")]
+	public ref bool IsCrouching => ref Schema.GetRef<bool>(this.Handle, "CBot", "m_isCrouching");
+
+	// m_forwardSpeed
+	[SchemaMember("CBot", "m_forwardSpeed")]
+	public ref float ForwardSpeed => ref Schema.GetRef<float>(this.Handle, "CBot", "m_forwardSpeed");
+
+	// m_leftSpeed
+	[SchemaMember("CBot", "m_leftSpeed")]
+	public ref float LeftSpeed => ref Schema.GetRef<float>(this.Handle, "CBot", "m_leftSpeed");
+
+	// m_verticalSpeed
+	[SchemaMember("CBot", "m_verticalSpeed")]
+	public ref float VerticalSpeed => ref Schema.GetRef<float>(this.Handle, "CBot", "m_verticalSpeed");
+
+	// m_buttonFlags
+	[SchemaMember("CBot", "m_buttonFlags")]
+	public ref UInt64 ButtonFlags => ref Schema.GetRef<UInt64>(this.Handle, "CBot", "m_buttonFlags");
+
+	// m_jumpTimestamp
+	[SchemaMember("CBot", "m_jumpTimestamp")]
+	public ref float JumpTimestamp => ref Schema.GetRef<float>(this.Handle, "CBot", "m_jumpTimestamp");
+
+	// m_viewForward
+	[SchemaMember("CBot", "m_viewForward")]
+	public Vector ViewForward => Schema.GetDeclaredClass<Vector>(this.Handle, "CBot", "m_viewForward");
+
+	// m_postureStackIndex
+	[SchemaMember("CBot", "m_postureStackIndex")]
+	public ref Int32 PostureStackIndex => ref Schema.GetRef<Int32>(this.Handle, "CBot", "m_postureStackIndex");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBreachCharge.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBreachCharge : CCSWeaponBase
+{
+    public CBreachCharge (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBreachChargeProjectile.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBreachChargeProjectile : CBaseGrenade
+{
+    public CBreachChargeProjectile (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBreakable.g.cs

@@ -0,0 +1,117 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBreakable : CBaseModelEntity
+{
+    public CBreakable (IntPtr pointer) : base(pointer) {}
+
+	// m_Material
+	[SchemaMember("CBreakable", "m_Material")]
+	public ref Materials Material => ref Schema.GetRef<Materials>(this.Handle, "CBreakable", "m_Material");
+
+	// m_hBreaker
+	[SchemaMember("CBreakable", "m_hBreaker")]
+	public CHandle<CBaseEntity> Breaker => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CBreakable", "m_hBreaker");
+
+	// m_Explosion
+	[SchemaMember("CBreakable", "m_Explosion")]
+	public ref Explosions Explosion => ref Schema.GetRef<Explosions>(this.Handle, "CBreakable", "m_Explosion");
+
+	// m_iszSpawnObject
+	[SchemaMember("CBreakable", "m_iszSpawnObject")]
+	public string SpawnObject
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBreakable", "m_iszSpawnObject"); }
+		set { Schema.SetString(this.Handle, "CBreakable", "m_iszSpawnObject", value); }
+	}
+
+	// m_flPressureDelay
+	[SchemaMember("CBreakable", "m_flPressureDelay")]
+	public ref float PressureDelay => ref Schema.GetRef<float>(this.Handle, "CBreakable", "m_flPressureDelay");
+
+	// m_iMinHealthDmg
+	[SchemaMember("CBreakable", "m_iMinHealthDmg")]
+	public ref Int32 MinHealthDmg => ref Schema.GetRef<Int32>(this.Handle, "CBreakable", "m_iMinHealthDmg");
+
+	// m_iszPropData
+	[SchemaMember("CBreakable", "m_iszPropData")]
+	public string PropData
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBreakable", "m_iszPropData"); }
+		set { Schema.SetString(this.Handle, "CBreakable", "m_iszPropData", value); }
+	}
+
+	// m_impactEnergyScale
+	[SchemaMember("CBreakable", "m_impactEnergyScale")]
+	public ref float ImpactEnergyScale => ref Schema.GetRef<float>(this.Handle, "CBreakable", "m_impactEnergyScale");
+
+	// m_nOverrideBlockLOS
+	[SchemaMember("CBreakable", "m_nOverrideBlockLOS")]
+	public ref EOverrideBlockLOS_t OverrideBlockLOS => ref Schema.GetRef<EOverrideBlockLOS_t>(this.Handle, "CBreakable", "m_nOverrideBlockLOS");
+
+	// m_OnBreak
+	[SchemaMember("CBreakable", "m_OnBreak")]
+	public CEntityIOOutput OnBreak => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBreakable", "m_OnBreak");
+
+	// m_flDmgModBullet
+	[SchemaMember("CBreakable", "m_flDmgModBullet")]
+	public ref float DmgModBullet => ref Schema.GetRef<float>(this.Handle, "CBreakable", "m_flDmgModBullet");
+
+	// m_flDmgModClub
+	[SchemaMember("CBreakable", "m_flDmgModClub")]
+	public ref float DmgModClub => ref Schema.GetRef<float>(this.Handle, "CBreakable", "m_flDmgModClub");
+
+	// m_flDmgModExplosive
+	[SchemaMember("CBreakable", "m_flDmgModExplosive")]
+	public ref float DmgModExplosive => ref Schema.GetRef<float>(this.Handle, "CBreakable", "m_flDmgModExplosive");
+
+	// m_flDmgModFire
+	[SchemaMember("CBreakable", "m_flDmgModFire")]
+	public ref float DmgModFire => ref Schema.GetRef<float>(this.Handle, "CBreakable", "m_flDmgModFire");
+
+	// m_iszPhysicsDamageTableName
+	[SchemaMember("CBreakable", "m_iszPhysicsDamageTableName")]
+	public string PhysicsDamageTableName
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBreakable", "m_iszPhysicsDamageTableName"); }
+		set { Schema.SetString(this.Handle, "CBreakable", "m_iszPhysicsDamageTableName", value); }
+	}
+
+	// m_iszBasePropData
+	[SchemaMember("CBreakable", "m_iszBasePropData")]
+	public string BasePropData
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBreakable", "m_iszBasePropData"); }
+		set { Schema.SetString(this.Handle, "CBreakable", "m_iszBasePropData", value); }
+	}
+
+	// m_iInteractions
+	[SchemaMember("CBreakable", "m_iInteractions")]
+	public ref Int32 Interactions => ref Schema.GetRef<Int32>(this.Handle, "CBreakable", "m_iInteractions");
+
+	// m_PerformanceMode
+	[SchemaMember("CBreakable", "m_PerformanceMode")]
+	public ref PerformanceMode_t PerformanceMode => ref Schema.GetRef<PerformanceMode_t>(this.Handle, "CBreakable", "m_PerformanceMode");
+
+	// m_hPhysicsAttacker
+	[SchemaMember("CBreakable", "m_hPhysicsAttacker")]
+	public CHandle<CBasePlayerPawn> PhysicsAttacker => Schema.GetDeclaredClass<CHandle<CBasePlayerPawn>>(this.Handle, "CBreakable", "m_hPhysicsAttacker");
+
+	// m_flLastPhysicsInfluenceTime
+	[SchemaMember("CBreakable", "m_flLastPhysicsInfluenceTime")]
+	public ref float LastPhysicsInfluenceTime => ref Schema.GetRef<float>(this.Handle, "CBreakable", "m_flLastPhysicsInfluenceTime");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBreakableProp.g.cs

@@ -0,0 +1,181 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBreakableProp : CBaseProp
+{
+    public CBreakableProp (IntPtr pointer) : base(pointer) {}
+
+	// m_OnBreak
+	[SchemaMember("CBreakableProp", "m_OnBreak")]
+	public CEntityIOOutput OnBreak => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBreakableProp", "m_OnBreak");
+
+	// m_OnTakeDamage
+	[SchemaMember("CBreakableProp", "m_OnTakeDamage")]
+	public CEntityIOOutput OnTakeDamage => Schema.GetDeclaredClass<CEntityIOOutput>(this.Handle, "CBreakableProp", "m_OnTakeDamage");
+
+	// m_impactEnergyScale
+	[SchemaMember("CBreakableProp", "m_impactEnergyScale")]
+	public ref float ImpactEnergyScale => ref Schema.GetRef<float>(this.Handle, "CBreakableProp", "m_impactEnergyScale");
+
+	// m_iMinHealthDmg
+	[SchemaMember("CBreakableProp", "m_iMinHealthDmg")]
+	public ref Int32 MinHealthDmg => ref Schema.GetRef<Int32>(this.Handle, "CBreakableProp", "m_iMinHealthDmg");
+
+	// m_preferredCarryAngles
+	[SchemaMember("CBreakableProp", "m_preferredCarryAngles")]
+	public QAngle PreferredCarryAngles => Schema.GetDeclaredClass<QAngle>(this.Handle, "CBreakableProp", "m_preferredCarryAngles");
+
+	// m_flPressureDelay
+	[SchemaMember("CBreakableProp", "m_flPressureDelay")]
+	public ref float PressureDelay => ref Schema.GetRef<float>(this.Handle, "CBreakableProp", "m_flPressureDelay");
+
+	// m_hBreaker
+	[SchemaMember("CBreakableProp", "m_hBreaker")]
+	public CHandle<CBaseEntity> Breaker => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CBreakableProp", "m_hBreaker");
+
+	// m_PerformanceMode
+	[SchemaMember("CBreakableProp", "m_PerformanceMode")]
+	public ref PerformanceMode_t PerformanceMode => ref Schema.GetRef<PerformanceMode_t>(this.Handle, "CBreakableProp", "m_PerformanceMode");
+
+	// m_flDmgModBullet
+	[SchemaMember("CBreakableProp", "m_flDmgModBullet")]
+	public ref float DmgModBullet => ref Schema.GetRef<float>(this.Handle, "CBreakableProp", "m_flDmgModBullet");
+
+	// m_flDmgModClub
+	[SchemaMember("CBreakableProp", "m_flDmgModClub")]
+	public ref float DmgModClub => ref Schema.GetRef<float>(this.Handle, "CBreakableProp", "m_flDmgModClub");
+
+	// m_flDmgModExplosive
+	[SchemaMember("CBreakableProp", "m_flDmgModExplosive")]
+	public ref float DmgModExplosive => ref Schema.GetRef<float>(this.Handle, "CBreakableProp", "m_flDmgModExplosive");
+
+	// m_flDmgModFire
+	[SchemaMember("CBreakableProp", "m_flDmgModFire")]
+	public ref float DmgModFire => ref Schema.GetRef<float>(this.Handle, "CBreakableProp", "m_flDmgModFire");
+
+	// m_iszPhysicsDamageTableName
+	[SchemaMember("CBreakableProp", "m_iszPhysicsDamageTableName")]
+	public string PhysicsDamageTableName
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBreakableProp", "m_iszPhysicsDamageTableName"); }
+		set { Schema.SetString(this.Handle, "CBreakableProp", "m_iszPhysicsDamageTableName", value); }
+	}
+
+	// m_iszBasePropData
+	[SchemaMember("CBreakableProp", "m_iszBasePropData")]
+	public string BasePropData
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBreakableProp", "m_iszBasePropData"); }
+		set { Schema.SetString(this.Handle, "CBreakableProp", "m_iszBasePropData", value); }
+	}
+
+	// m_iInteractions
+	[SchemaMember("CBreakableProp", "m_iInteractions")]
+	public ref Int32 Interactions => ref Schema.GetRef<Int32>(this.Handle, "CBreakableProp", "m_iInteractions");
+
+	// m_flPreventDamageBeforeTime
+	[SchemaMember("CBreakableProp", "m_flPreventDamageBeforeTime")]
+	public ref float PreventDamageBeforeTime => ref Schema.GetRef<float>(this.Handle, "CBreakableProp", "m_flPreventDamageBeforeTime");
+
+	// m_bHasBreakPiecesOrCommands
+	[SchemaMember("CBreakableProp", "m_bHasBreakPiecesOrCommands")]
+	public ref bool HasBreakPiecesOrCommands => ref Schema.GetRef<bool>(this.Handle, "CBreakableProp", "m_bHasBreakPiecesOrCommands");
+
+	// m_explodeDamage
+	[SchemaMember("CBreakableProp", "m_explodeDamage")]
+	public ref float ExplodeDamage => ref Schema.GetRef<float>(this.Handle, "CBreakableProp", "m_explodeDamage");
+
+	// m_explodeRadius
+	[SchemaMember("CBreakableProp", "m_explodeRadius")]
+	public ref float ExplodeRadius => ref Schema.GetRef<float>(this.Handle, "CBreakableProp", "m_explodeRadius");
+
+	// m_explosionDelay
+	[SchemaMember("CBreakableProp", "m_explosionDelay")]
+	public ref float ExplosionDelay => ref Schema.GetRef<float>(this.Handle, "CBreakableProp", "m_explosionDelay");
+
+	// m_explosionBuildupSound
+	[SchemaMember("CBreakableProp", "m_explosionBuildupSound")]
+	public string ExplosionBuildupSound
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBreakableProp", "m_explosionBuildupSound"); }
+		set { Schema.SetString(this.Handle, "CBreakableProp", "m_explosionBuildupSound", value); }
+	}
+
+	// m_explosionCustomEffect
+	[SchemaMember("CBreakableProp", "m_explosionCustomEffect")]
+	public string ExplosionCustomEffect
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBreakableProp", "m_explosionCustomEffect"); }
+		set { Schema.SetString(this.Handle, "CBreakableProp", "m_explosionCustomEffect", value); }
+	}
+
+	// m_explosionCustomSound
+	[SchemaMember("CBreakableProp", "m_explosionCustomSound")]
+	public string ExplosionCustomSound
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBreakableProp", "m_explosionCustomSound"); }
+		set { Schema.SetString(this.Handle, "CBreakableProp", "m_explosionCustomSound", value); }
+	}
+
+	// m_explosionModifier
+	[SchemaMember("CBreakableProp", "m_explosionModifier")]
+	public string ExplosionModifier
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBreakableProp", "m_explosionModifier"); }
+		set { Schema.SetString(this.Handle, "CBreakableProp", "m_explosionModifier", value); }
+	}
+
+	// m_hPhysicsAttacker
+	[SchemaMember("CBreakableProp", "m_hPhysicsAttacker")]
+	public CHandle<CBasePlayerPawn> PhysicsAttacker => Schema.GetDeclaredClass<CHandle<CBasePlayerPawn>>(this.Handle, "CBreakableProp", "m_hPhysicsAttacker");
+
+	// m_flLastPhysicsInfluenceTime
+	[SchemaMember("CBreakableProp", "m_flLastPhysicsInfluenceTime")]
+	public ref float LastPhysicsInfluenceTime => ref Schema.GetRef<float>(this.Handle, "CBreakableProp", "m_flLastPhysicsInfluenceTime");
+
+	// m_bOriginalBlockLOS
+	[SchemaMember("CBreakableProp", "m_bOriginalBlockLOS")]
+	public ref bool OriginalBlockLOS => ref Schema.GetRef<bool>(this.Handle, "CBreakableProp", "m_bOriginalBlockLOS");
+
+	// m_flDefaultFadeScale
+	[SchemaMember("CBreakableProp", "m_flDefaultFadeScale")]
+	public ref float DefaultFadeScale => ref Schema.GetRef<float>(this.Handle, "CBreakableProp", "m_flDefaultFadeScale");
+
+	// m_hLastAttacker
+	[SchemaMember("CBreakableProp", "m_hLastAttacker")]
+	public CHandle<CBaseEntity> LastAttacker => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CBreakableProp", "m_hLastAttacker");
+
+	// m_hFlareEnt
+	[SchemaMember("CBreakableProp", "m_hFlareEnt")]
+	public CHandle<CBaseEntity> FlareEnt => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CBreakableProp", "m_hFlareEnt");
+
+	// m_bUsePuntSound
+	[SchemaMember("CBreakableProp", "m_bUsePuntSound")]
+	public ref bool UsePuntSound => ref Schema.GetRef<bool>(this.Handle, "CBreakableProp", "m_bUsePuntSound");
+
+	// m_iszPuntSound
+	[SchemaMember("CBreakableProp", "m_iszPuntSound")]
+	public string PuntSound
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CBreakableProp", "m_iszPuntSound"); }
+		set { Schema.SetString(this.Handle, "CBreakableProp", "m_iszPuntSound", value); }
+	}
+
+	// m_noGhostCollision
+	[SchemaMember("CBreakableProp", "m_noGhostCollision")]
+	public ref bool NoGhostCollision => ref Schema.GetRef<bool>(this.Handle, "CBreakableProp", "m_noGhostCollision");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBubbling.g.cs

@@ -0,0 +1,33 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBubbling : CBaseModelEntity
+{
+    public CBubbling (IntPtr pointer) : base(pointer) {}
+
+	// m_density
+	[SchemaMember("CBubbling", "m_density")]
+	public ref Int32 Density => ref Schema.GetRef<Int32>(this.Handle, "CBubbling", "m_density");
+
+	// m_frequency
+	[SchemaMember("CBubbling", "m_frequency")]
+	public ref Int32 Frequency => ref Schema.GetRef<Int32>(this.Handle, "CBubbling", "m_frequency");
+
+	// m_state
+	[SchemaMember("CBubbling", "m_state")]
+	public ref Int32 State => ref Schema.GetRef<Int32>(this.Handle, "CBubbling", "m_state");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBumpMine.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBumpMine : CCSWeaponBase
+{
+    public CBumpMine (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBumpMineProjectile.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBumpMineProjectile : CBaseGrenade
+{
+    public CBumpMineProjectile (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBuoyancyHelper.g.cs

@@ -0,0 +1,25 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBuoyancyHelper : NativeObject
+{
+    public CBuoyancyHelper (IntPtr pointer) : base(pointer) {}
+
+	// m_flFluidDensity
+	[SchemaMember("CBuoyancyHelper", "m_flFluidDensity")]
+	public ref float FluidDensity => ref Schema.GetRef<float>(this.Handle, "CBuoyancyHelper", "m_flFluidDensity");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBuyZone.g.cs

@@ -0,0 +1,25 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CBuyZone : CBaseTrigger
+{
+    public CBuyZone (IntPtr pointer) : base(pointer) {}
+
+	// m_LegacyTeamNum
+	[SchemaMember("CBuyZone", "m_LegacyTeamNum")]
+	public ref Int32 LegacyTeamNum => ref Schema.GetRef<Int32>(this.Handle, "CBuyZone", "m_LegacyTeamNum");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CC4.g.cs

@@ -0,0 +1,69 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CC4 : CCSWeaponBase
+{
+    public CC4 (IntPtr pointer) : base(pointer) {}
+
+	// m_vecLastValidPlayerHeldPosition
+	[SchemaMember("CC4", "m_vecLastValidPlayerHeldPosition")]
+	public Vector LastValidPlayerHeldPosition => Schema.GetDeclaredClass<Vector>(this.Handle, "CC4", "m_vecLastValidPlayerHeldPosition");
+
+	// m_vecLastValidDroppedPosition
+	[SchemaMember("CC4", "m_vecLastValidDroppedPosition")]
+	public Vector LastValidDroppedPosition => Schema.GetDeclaredClass<Vector>(this.Handle, "CC4", "m_vecLastValidDroppedPosition");
+
+	// m_bDoValidDroppedPositionCheck
+	[SchemaMember("CC4", "m_bDoValidDroppedPositionCheck")]
+	public ref bool DoValidDroppedPositionCheck => ref Schema.GetRef<bool>(this.Handle, "CC4", "m_bDoValidDroppedPositionCheck");
+
+	// m_bStartedArming
+	[SchemaMember("CC4", "m_bStartedArming")]
+	public ref bool StartedArming => ref Schema.GetRef<bool>(this.Handle, "CC4", "m_bStartedArming");
+
+	// m_fArmedTime
+	[SchemaMember("CC4", "m_fArmedTime")]
+	public ref float ArmedTime => ref Schema.GetRef<float>(this.Handle, "CC4", "m_fArmedTime");
+
+	// m_bBombPlacedAnimation
+	[SchemaMember("CC4", "m_bBombPlacedAnimation")]
+	public ref bool BombPlacedAnimation => ref Schema.GetRef<bool>(this.Handle, "CC4", "m_bBombPlacedAnimation");
+
+	// m_bIsPlantingViaUse
+	[SchemaMember("CC4", "m_bIsPlantingViaUse")]
+	public ref bool IsPlantingViaUse => ref Schema.GetRef<bool>(this.Handle, "CC4", "m_bIsPlantingViaUse");
+
+	// m_entitySpottedState
+	[SchemaMember("CC4", "m_entitySpottedState")]
+	public EntitySpottedState_t EntitySpottedState => Schema.GetDeclaredClass<EntitySpottedState_t>(this.Handle, "CC4", "m_entitySpottedState");
+
+	// m_nSpotRules
+	[SchemaMember("CC4", "m_nSpotRules")]
+	public ref Int32 SpotRules => ref Schema.GetRef<Int32>(this.Handle, "CC4", "m_nSpotRules");
+
+	// m_bPlayedArmingBeeps
+	[SchemaMember("CC4", "m_bPlayedArmingBeeps")]
+	public Span<bool> PlayedArmingBeeps => Schema.GetFixedArray<bool>(this.Handle, "CC4", "m_bPlayedArmingBeeps", 7);
+
+	// m_bBombPlanted
+	[SchemaMember("CC4", "m_bBombPlanted")]
+	public ref bool BombPlanted => ref Schema.GetRef<bool>(this.Handle, "CC4", "m_bBombPlanted");
+
+	// m_bDroppedFromDeath
+	[SchemaMember("CC4", "m_bDroppedFromDeath")]
+	public ref bool DroppedFromDeath => ref Schema.GetRef<bool>(this.Handle, "CC4", "m_bDroppedFromDeath");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSBot.g.cs

@@ -0,0 +1,589 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSBot : CBot
+{
+    public CCSBot (IntPtr pointer) : base(pointer) {}
+
+	// m_lastCoopSpawnPoint
+	[SchemaMember("CCSBot", "m_lastCoopSpawnPoint")]
+	public CHandle<SpawnPointCoopEnemy> LastCoopSpawnPoint => Schema.GetDeclaredClass<CHandle<SpawnPointCoopEnemy>>(this.Handle, "CCSBot", "m_lastCoopSpawnPoint");
+
+	// m_eyePosition
+	[SchemaMember("CCSBot", "m_eyePosition")]
+	public Vector EyePosition => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSBot", "m_eyePosition");
+
+	// m_name
+	[SchemaMember("CCSBot", "m_name")]
+	public string Name
+	{
+		get { return Schema.GetString(this.Handle, "CCSBot", "m_name"); }
+		set { Schema.SetString(this.Handle, "CCSBot", "m_name", value); }
+	}
+
+	// m_combatRange
+	[SchemaMember("CCSBot", "m_combatRange")]
+	public ref float CombatRange => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_combatRange");
+
+	// m_isRogue
+	[SchemaMember("CCSBot", "m_isRogue")]
+	public ref bool IsRogue => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_isRogue");
+
+	// m_rogueTimer
+	[SchemaMember("CCSBot", "m_rogueTimer")]
+	public CountdownTimer RogueTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_rogueTimer");
+
+	// m_diedLastRound
+	[SchemaMember("CCSBot", "m_diedLastRound")]
+	public ref bool DiedLastRound => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_diedLastRound");
+
+	// m_safeTime
+	[SchemaMember("CCSBot", "m_safeTime")]
+	public ref float SafeTime => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_safeTime");
+
+	// m_wasSafe
+	[SchemaMember("CCSBot", "m_wasSafe")]
+	public ref bool WasSafe => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_wasSafe");
+
+	// m_blindFire
+	[SchemaMember("CCSBot", "m_blindFire")]
+	public ref bool BlindFire => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_blindFire");
+
+	// m_surpriseTimer
+	[SchemaMember("CCSBot", "m_surpriseTimer")]
+	public CountdownTimer SurpriseTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_surpriseTimer");
+
+	// m_bAllowActive
+	[SchemaMember("CCSBot", "m_bAllowActive")]
+	public ref bool AllowActive => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_bAllowActive");
+
+	// m_isFollowing
+	[SchemaMember("CCSBot", "m_isFollowing")]
+	public ref bool IsFollowing => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_isFollowing");
+
+	// m_leader
+	[SchemaMember("CCSBot", "m_leader")]
+	public CHandle<CCSPlayerPawn> Leader => Schema.GetDeclaredClass<CHandle<CCSPlayerPawn>>(this.Handle, "CCSBot", "m_leader");
+
+	// m_followTimestamp
+	[SchemaMember("CCSBot", "m_followTimestamp")]
+	public ref float FollowTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_followTimestamp");
+
+	// m_allowAutoFollowTime
+	[SchemaMember("CCSBot", "m_allowAutoFollowTime")]
+	public ref float AllowAutoFollowTime => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_allowAutoFollowTime");
+
+	// m_hurryTimer
+	[SchemaMember("CCSBot", "m_hurryTimer")]
+	public CountdownTimer HurryTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_hurryTimer");
+
+	// m_alertTimer
+	[SchemaMember("CCSBot", "m_alertTimer")]
+	public CountdownTimer AlertTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_alertTimer");
+
+	// m_sneakTimer
+	[SchemaMember("CCSBot", "m_sneakTimer")]
+	public CountdownTimer SneakTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_sneakTimer");
+
+	// m_panicTimer
+	[SchemaMember("CCSBot", "m_panicTimer")]
+	public CountdownTimer PanicTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_panicTimer");
+
+	// m_stateTimestamp
+	[SchemaMember("CCSBot", "m_stateTimestamp")]
+	public ref float StateTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_stateTimestamp");
+
+	// m_isAttacking
+	[SchemaMember("CCSBot", "m_isAttacking")]
+	public ref bool IsAttacking => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_isAttacking");
+
+	// m_isOpeningDoor
+	[SchemaMember("CCSBot", "m_isOpeningDoor")]
+	public ref bool IsOpeningDoor => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_isOpeningDoor");
+
+	// m_taskEntity
+	[SchemaMember("CCSBot", "m_taskEntity")]
+	public CHandle<CBaseEntity> TaskEntity => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CCSBot", "m_taskEntity");
+
+	// m_goalPosition
+	[SchemaMember("CCSBot", "m_goalPosition")]
+	public Vector GoalPosition => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSBot", "m_goalPosition");
+
+	// m_goalEntity
+	[SchemaMember("CCSBot", "m_goalEntity")]
+	public CHandle<CBaseEntity> GoalEntity => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CCSBot", "m_goalEntity");
+
+	// m_avoid
+	[SchemaMember("CCSBot", "m_avoid")]
+	public CHandle<CBaseEntity> Avoid => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CCSBot", "m_avoid");
+
+	// m_avoidTimestamp
+	[SchemaMember("CCSBot", "m_avoidTimestamp")]
+	public ref float AvoidTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_avoidTimestamp");
+
+	// m_isStopping
+	[SchemaMember("CCSBot", "m_isStopping")]
+	public ref bool IsStopping => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_isStopping");
+
+	// m_hasVisitedEnemySpawn
+	[SchemaMember("CCSBot", "m_hasVisitedEnemySpawn")]
+	public ref bool HasVisitedEnemySpawn => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_hasVisitedEnemySpawn");
+
+	// m_stillTimer
+	[SchemaMember("CCSBot", "m_stillTimer")]
+	public IntervalTimer StillTimer => Schema.GetDeclaredClass<IntervalTimer>(this.Handle, "CCSBot", "m_stillTimer");
+
+	// m_bEyeAnglesUnderPathFinderControl
+	[SchemaMember("CCSBot", "m_bEyeAnglesUnderPathFinderControl")]
+	public ref bool EyeAnglesUnderPathFinderControl => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_bEyeAnglesUnderPathFinderControl");
+
+	// m_pathIndex
+	[SchemaMember("CCSBot", "m_pathIndex")]
+	public ref Int32 PathIndex => ref Schema.GetRef<Int32>(this.Handle, "CCSBot", "m_pathIndex");
+
+	// m_areaEnteredTimestamp
+	[SchemaMember("CCSBot", "m_areaEnteredTimestamp")]
+	public ref float AreaEnteredTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_areaEnteredTimestamp");
+
+	// m_repathTimer
+	[SchemaMember("CCSBot", "m_repathTimer")]
+	public CountdownTimer RepathTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_repathTimer");
+
+	// m_avoidFriendTimer
+	[SchemaMember("CCSBot", "m_avoidFriendTimer")]
+	public CountdownTimer AvoidFriendTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_avoidFriendTimer");
+
+	// m_isFriendInTheWay
+	[SchemaMember("CCSBot", "m_isFriendInTheWay")]
+	public ref bool IsFriendInTheWay => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_isFriendInTheWay");
+
+	// m_politeTimer
+	[SchemaMember("CCSBot", "m_politeTimer")]
+	public CountdownTimer PoliteTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_politeTimer");
+
+	// m_isWaitingBehindFriend
+	[SchemaMember("CCSBot", "m_isWaitingBehindFriend")]
+	public ref bool IsWaitingBehindFriend => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_isWaitingBehindFriend");
+
+	// m_pathLadderEnd
+	[SchemaMember("CCSBot", "m_pathLadderEnd")]
+	public ref float PathLadderEnd => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_pathLadderEnd");
+
+	// m_mustRunTimer
+	[SchemaMember("CCSBot", "m_mustRunTimer")]
+	public CountdownTimer MustRunTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_mustRunTimer");
+
+	// m_waitTimer
+	[SchemaMember("CCSBot", "m_waitTimer")]
+	public CountdownTimer WaitTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_waitTimer");
+
+	// m_updateTravelDistanceTimer
+	[SchemaMember("CCSBot", "m_updateTravelDistanceTimer")]
+	public CountdownTimer UpdateTravelDistanceTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_updateTravelDistanceTimer");
+
+	// m_playerTravelDistance
+	[SchemaMember("CCSBot", "m_playerTravelDistance")]
+	public Span<float> PlayerTravelDistance => Schema.GetFixedArray<float>(this.Handle, "CCSBot", "m_playerTravelDistance", 64);
+
+	// m_travelDistancePhase
+	[SchemaMember("CCSBot", "m_travelDistancePhase")]
+	public ref byte TravelDistancePhase => ref Schema.GetRef<byte>(this.Handle, "CCSBot", "m_travelDistancePhase");
+
+	// m_hostageEscortCount
+	[SchemaMember("CCSBot", "m_hostageEscortCount")]
+	public ref byte HostageEscortCount => ref Schema.GetRef<byte>(this.Handle, "CCSBot", "m_hostageEscortCount");
+
+	// m_hostageEscortCountTimestamp
+	[SchemaMember("CCSBot", "m_hostageEscortCountTimestamp")]
+	public ref float HostageEscortCountTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_hostageEscortCountTimestamp");
+
+	// m_desiredTeam
+	[SchemaMember("CCSBot", "m_desiredTeam")]
+	public ref Int32 DesiredTeam => ref Schema.GetRef<Int32>(this.Handle, "CCSBot", "m_desiredTeam");
+
+	// m_hasJoined
+	[SchemaMember("CCSBot", "m_hasJoined")]
+	public ref bool HasJoined => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_hasJoined");
+
+	// m_isWaitingForHostage
+	[SchemaMember("CCSBot", "m_isWaitingForHostage")]
+	public ref bool IsWaitingForHostage => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_isWaitingForHostage");
+
+	// m_inhibitWaitingForHostageTimer
+	[SchemaMember("CCSBot", "m_inhibitWaitingForHostageTimer")]
+	public CountdownTimer InhibitWaitingForHostageTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_inhibitWaitingForHostageTimer");
+
+	// m_waitForHostageTimer
+	[SchemaMember("CCSBot", "m_waitForHostageTimer")]
+	public CountdownTimer WaitForHostageTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_waitForHostageTimer");
+
+	// m_noisePosition
+	[SchemaMember("CCSBot", "m_noisePosition")]
+	public Vector NoisePosition => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSBot", "m_noisePosition");
+
+	// m_noiseTravelDistance
+	[SchemaMember("CCSBot", "m_noiseTravelDistance")]
+	public ref float NoiseTravelDistance => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_noiseTravelDistance");
+
+	// m_noiseTimestamp
+	[SchemaMember("CCSBot", "m_noiseTimestamp")]
+	public ref float NoiseTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_noiseTimestamp");
+
+	// m_noiseSource
+	[SchemaMember("CCSBot", "m_noiseSource")]
+	public CCSPlayerPawn? NoiseSource => Schema.GetPointer<CCSPlayerPawn>(this.Handle, "CCSBot", "m_noiseSource");
+
+	// m_noiseBendTimer
+	[SchemaMember("CCSBot", "m_noiseBendTimer")]
+	public CountdownTimer NoiseBendTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_noiseBendTimer");
+
+	// m_bentNoisePosition
+	[SchemaMember("CCSBot", "m_bentNoisePosition")]
+	public Vector BentNoisePosition => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSBot", "m_bentNoisePosition");
+
+	// m_bendNoisePositionValid
+	[SchemaMember("CCSBot", "m_bendNoisePositionValid")]
+	public ref bool BendNoisePositionValid => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_bendNoisePositionValid");
+
+	// m_lookAroundStateTimestamp
+	[SchemaMember("CCSBot", "m_lookAroundStateTimestamp")]
+	public ref float LookAroundStateTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_lookAroundStateTimestamp");
+
+	// m_lookAheadAngle
+	[SchemaMember("CCSBot", "m_lookAheadAngle")]
+	public ref float LookAheadAngle => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_lookAheadAngle");
+
+	// m_forwardAngle
+	[SchemaMember("CCSBot", "m_forwardAngle")]
+	public ref float ForwardAngle => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_forwardAngle");
+
+	// m_inhibitLookAroundTimestamp
+	[SchemaMember("CCSBot", "m_inhibitLookAroundTimestamp")]
+	public ref float InhibitLookAroundTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_inhibitLookAroundTimestamp");
+
+	// m_lookAtSpot
+	[SchemaMember("CCSBot", "m_lookAtSpot")]
+	public Vector LookAtSpot => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSBot", "m_lookAtSpot");
+
+	// m_lookAtSpotDuration
+	[SchemaMember("CCSBot", "m_lookAtSpotDuration")]
+	public ref float LookAtSpotDuration => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_lookAtSpotDuration");
+
+	// m_lookAtSpotTimestamp
+	[SchemaMember("CCSBot", "m_lookAtSpotTimestamp")]
+	public ref float LookAtSpotTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_lookAtSpotTimestamp");
+
+	// m_lookAtSpotAngleTolerance
+	[SchemaMember("CCSBot", "m_lookAtSpotAngleTolerance")]
+	public ref float LookAtSpotAngleTolerance => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_lookAtSpotAngleTolerance");
+
+	// m_lookAtSpotClearIfClose
+	[SchemaMember("CCSBot", "m_lookAtSpotClearIfClose")]
+	public ref bool LookAtSpotClearIfClose => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_lookAtSpotClearIfClose");
+
+	// m_lookAtSpotAttack
+	[SchemaMember("CCSBot", "m_lookAtSpotAttack")]
+	public ref bool LookAtSpotAttack => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_lookAtSpotAttack");
+
+	// m_lookAtDesc
+	[SchemaMember("CCSBot", "m_lookAtDesc")]
+	public string LookAtDesc
+	{
+		get { return Schema.GetString(this.Handle, "CCSBot", "m_lookAtDesc"); }
+		set { Schema.SetString(this.Handle, "CCSBot", "m_lookAtDesc", value); }
+	}
+
+	// m_peripheralTimestamp
+	[SchemaMember("CCSBot", "m_peripheralTimestamp")]
+	public ref float PeripheralTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_peripheralTimestamp");
+
+	// m_approachPointCount
+	[SchemaMember("CCSBot", "m_approachPointCount")]
+	public ref byte ApproachPointCount => ref Schema.GetRef<byte>(this.Handle, "CCSBot", "m_approachPointCount");
+
+	// m_approachPointViewPosition
+	[SchemaMember("CCSBot", "m_approachPointViewPosition")]
+	public Vector ApproachPointViewPosition => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSBot", "m_approachPointViewPosition");
+
+	// m_viewSteadyTimer
+	[SchemaMember("CCSBot", "m_viewSteadyTimer")]
+	public IntervalTimer ViewSteadyTimer => Schema.GetDeclaredClass<IntervalTimer>(this.Handle, "CCSBot", "m_viewSteadyTimer");
+
+	// m_tossGrenadeTimer
+	[SchemaMember("CCSBot", "m_tossGrenadeTimer")]
+	public CountdownTimer TossGrenadeTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_tossGrenadeTimer");
+
+	// m_isAvoidingGrenade
+	[SchemaMember("CCSBot", "m_isAvoidingGrenade")]
+	public CountdownTimer IsAvoidingGrenade => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_isAvoidingGrenade");
+
+	// m_spotCheckTimestamp
+	[SchemaMember("CCSBot", "m_spotCheckTimestamp")]
+	public ref float SpotCheckTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_spotCheckTimestamp");
+
+	// m_checkedHidingSpotCount
+	[SchemaMember("CCSBot", "m_checkedHidingSpotCount")]
+	public ref Int32 CheckedHidingSpotCount => ref Schema.GetRef<Int32>(this.Handle, "CCSBot", "m_checkedHidingSpotCount");
+
+	// m_lookPitch
+	[SchemaMember("CCSBot", "m_lookPitch")]
+	public ref float LookPitch => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_lookPitch");
+
+	// m_lookPitchVel
+	[SchemaMember("CCSBot", "m_lookPitchVel")]
+	public ref float LookPitchVel => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_lookPitchVel");
+
+	// m_lookYaw
+	[SchemaMember("CCSBot", "m_lookYaw")]
+	public ref float LookYaw => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_lookYaw");
+
+	// m_lookYawVel
+	[SchemaMember("CCSBot", "m_lookYawVel")]
+	public ref float LookYawVel => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_lookYawVel");
+
+	// m_targetSpot
+	[SchemaMember("CCSBot", "m_targetSpot")]
+	public Vector TargetSpot => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSBot", "m_targetSpot");
+
+	// m_targetSpotVelocity
+	[SchemaMember("CCSBot", "m_targetSpotVelocity")]
+	public Vector TargetSpotVelocity => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSBot", "m_targetSpotVelocity");
+
+	// m_targetSpotPredicted
+	[SchemaMember("CCSBot", "m_targetSpotPredicted")]
+	public Vector TargetSpotPredicted => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSBot", "m_targetSpotPredicted");
+
+	// m_aimError
+	[SchemaMember("CCSBot", "m_aimError")]
+	public QAngle AimError => Schema.GetDeclaredClass<QAngle>(this.Handle, "CCSBot", "m_aimError");
+
+	// m_aimGoal
+	[SchemaMember("CCSBot", "m_aimGoal")]
+	public QAngle AimGoal => Schema.GetDeclaredClass<QAngle>(this.Handle, "CCSBot", "m_aimGoal");
+
+	// m_targetSpotTime
+	[SchemaMember("CCSBot", "m_targetSpotTime")]
+	public ref float TargetSpotTime => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_targetSpotTime");
+
+	// m_aimFocus
+	[SchemaMember("CCSBot", "m_aimFocus")]
+	public ref float AimFocus => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_aimFocus");
+
+	// m_aimFocusInterval
+	[SchemaMember("CCSBot", "m_aimFocusInterval")]
+	public ref float AimFocusInterval => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_aimFocusInterval");
+
+	// m_aimFocusNextUpdate
+	[SchemaMember("CCSBot", "m_aimFocusNextUpdate")]
+	public ref float AimFocusNextUpdate => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_aimFocusNextUpdate");
+
+	// m_ignoreEnemiesTimer
+	[SchemaMember("CCSBot", "m_ignoreEnemiesTimer")]
+	public CountdownTimer IgnoreEnemiesTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_ignoreEnemiesTimer");
+
+	// m_enemy
+	[SchemaMember("CCSBot", "m_enemy")]
+	public CHandle<CCSPlayerPawn> Enemy => Schema.GetDeclaredClass<CHandle<CCSPlayerPawn>>(this.Handle, "CCSBot", "m_enemy");
+
+	// m_isEnemyVisible
+	[SchemaMember("CCSBot", "m_isEnemyVisible")]
+	public ref bool IsEnemyVisible => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_isEnemyVisible");
+
+	// m_visibleEnemyParts
+	[SchemaMember("CCSBot", "m_visibleEnemyParts")]
+	public ref byte VisibleEnemyParts => ref Schema.GetRef<byte>(this.Handle, "CCSBot", "m_visibleEnemyParts");
+
+	// m_lastEnemyPosition
+	[SchemaMember("CCSBot", "m_lastEnemyPosition")]
+	public Vector LastEnemyPosition => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSBot", "m_lastEnemyPosition");
+
+	// m_lastSawEnemyTimestamp
+	[SchemaMember("CCSBot", "m_lastSawEnemyTimestamp")]
+	public ref float LastSawEnemyTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_lastSawEnemyTimestamp");
+
+	// m_firstSawEnemyTimestamp
+	[SchemaMember("CCSBot", "m_firstSawEnemyTimestamp")]
+	public ref float FirstSawEnemyTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_firstSawEnemyTimestamp");
+
+	// m_currentEnemyAcquireTimestamp
+	[SchemaMember("CCSBot", "m_currentEnemyAcquireTimestamp")]
+	public ref float CurrentEnemyAcquireTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_currentEnemyAcquireTimestamp");
+
+	// m_enemyDeathTimestamp
+	[SchemaMember("CCSBot", "m_enemyDeathTimestamp")]
+	public ref float EnemyDeathTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_enemyDeathTimestamp");
+
+	// m_friendDeathTimestamp
+	[SchemaMember("CCSBot", "m_friendDeathTimestamp")]
+	public ref float FriendDeathTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_friendDeathTimestamp");
+
+	// m_isLastEnemyDead
+	[SchemaMember("CCSBot", "m_isLastEnemyDead")]
+	public ref bool IsLastEnemyDead => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_isLastEnemyDead");
+
+	// m_nearbyEnemyCount
+	[SchemaMember("CCSBot", "m_nearbyEnemyCount")]
+	public ref Int32 NearbyEnemyCount => ref Schema.GetRef<Int32>(this.Handle, "CCSBot", "m_nearbyEnemyCount");
+
+	// m_bomber
+	[SchemaMember("CCSBot", "m_bomber")]
+	public CHandle<CCSPlayerPawn> Bomber => Schema.GetDeclaredClass<CHandle<CCSPlayerPawn>>(this.Handle, "CCSBot", "m_bomber");
+
+	// m_nearbyFriendCount
+	[SchemaMember("CCSBot", "m_nearbyFriendCount")]
+	public ref Int32 NearbyFriendCount => ref Schema.GetRef<Int32>(this.Handle, "CCSBot", "m_nearbyFriendCount");
+
+	// m_closestVisibleFriend
+	[SchemaMember("CCSBot", "m_closestVisibleFriend")]
+	public CHandle<CCSPlayerPawn> ClosestVisibleFriend => Schema.GetDeclaredClass<CHandle<CCSPlayerPawn>>(this.Handle, "CCSBot", "m_closestVisibleFriend");
+
+	// m_closestVisibleHumanFriend
+	[SchemaMember("CCSBot", "m_closestVisibleHumanFriend")]
+	public CHandle<CCSPlayerPawn> ClosestVisibleHumanFriend => Schema.GetDeclaredClass<CHandle<CCSPlayerPawn>>(this.Handle, "CCSBot", "m_closestVisibleHumanFriend");
+
+	// m_attentionInterval
+	[SchemaMember("CCSBot", "m_attentionInterval")]
+	public IntervalTimer AttentionInterval => Schema.GetDeclaredClass<IntervalTimer>(this.Handle, "CCSBot", "m_attentionInterval");
+
+	// m_attacker
+	[SchemaMember("CCSBot", "m_attacker")]
+	public CHandle<CCSPlayerPawn> Attacker => Schema.GetDeclaredClass<CHandle<CCSPlayerPawn>>(this.Handle, "CCSBot", "m_attacker");
+
+	// m_attackedTimestamp
+	[SchemaMember("CCSBot", "m_attackedTimestamp")]
+	public ref float AttackedTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_attackedTimestamp");
+
+	// m_burnedByFlamesTimer
+	[SchemaMember("CCSBot", "m_burnedByFlamesTimer")]
+	public IntervalTimer BurnedByFlamesTimer => Schema.GetDeclaredClass<IntervalTimer>(this.Handle, "CCSBot", "m_burnedByFlamesTimer");
+
+	// m_lastVictimID
+	[SchemaMember("CCSBot", "m_lastVictimID")]
+	public ref Int32 LastVictimID => ref Schema.GetRef<Int32>(this.Handle, "CCSBot", "m_lastVictimID");
+
+	// m_isAimingAtEnemy
+	[SchemaMember("CCSBot", "m_isAimingAtEnemy")]
+	public ref bool IsAimingAtEnemy => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_isAimingAtEnemy");
+
+	// m_isRapidFiring
+	[SchemaMember("CCSBot", "m_isRapidFiring")]
+	public ref bool IsRapidFiring => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_isRapidFiring");
+
+	// m_equipTimer
+	[SchemaMember("CCSBot", "m_equipTimer")]
+	public IntervalTimer EquipTimer => Schema.GetDeclaredClass<IntervalTimer>(this.Handle, "CCSBot", "m_equipTimer");
+
+	// m_zoomTimer
+	[SchemaMember("CCSBot", "m_zoomTimer")]
+	public CountdownTimer ZoomTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_zoomTimer");
+
+	// m_fireWeaponTimestamp
+	[SchemaMember("CCSBot", "m_fireWeaponTimestamp")]
+	public ref float FireWeaponTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_fireWeaponTimestamp");
+
+	// m_lookForWeaponsOnGroundTimer
+	[SchemaMember("CCSBot", "m_lookForWeaponsOnGroundTimer")]
+	public CountdownTimer LookForWeaponsOnGroundTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_lookForWeaponsOnGroundTimer");
+
+	// m_bIsSleeping
+	[SchemaMember("CCSBot", "m_bIsSleeping")]
+	public ref bool IsSleeping => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_bIsSleeping");
+
+	// m_isEnemySniperVisible
+	[SchemaMember("CCSBot", "m_isEnemySniperVisible")]
+	public ref bool IsEnemySniperVisible => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_isEnemySniperVisible");
+
+	// m_sawEnemySniperTimer
+	[SchemaMember("CCSBot", "m_sawEnemySniperTimer")]
+	public CountdownTimer SawEnemySniperTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_sawEnemySniperTimer");
+
+	// m_enemyQueueIndex
+	[SchemaMember("CCSBot", "m_enemyQueueIndex")]
+	public ref byte EnemyQueueIndex => ref Schema.GetRef<byte>(this.Handle, "CCSBot", "m_enemyQueueIndex");
+
+	// m_enemyQueueCount
+	[SchemaMember("CCSBot", "m_enemyQueueCount")]
+	public ref byte EnemyQueueCount => ref Schema.GetRef<byte>(this.Handle, "CCSBot", "m_enemyQueueCount");
+
+	// m_enemyQueueAttendIndex
+	[SchemaMember("CCSBot", "m_enemyQueueAttendIndex")]
+	public ref byte EnemyQueueAttendIndex => ref Schema.GetRef<byte>(this.Handle, "CCSBot", "m_enemyQueueAttendIndex");
+
+	// m_isStuck
+	[SchemaMember("CCSBot", "m_isStuck")]
+	public ref bool IsStuck => ref Schema.GetRef<bool>(this.Handle, "CCSBot", "m_isStuck");
+
+	// m_stuckTimestamp
+	[SchemaMember("CCSBot", "m_stuckTimestamp")]
+	public ref float StuckTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_stuckTimestamp");
+
+	// m_stuckSpot
+	[SchemaMember("CCSBot", "m_stuckSpot")]
+	public Vector StuckSpot => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSBot", "m_stuckSpot");
+
+	// m_wiggleTimer
+	[SchemaMember("CCSBot", "m_wiggleTimer")]
+	public CountdownTimer WiggleTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_wiggleTimer");
+
+	// m_stuckJumpTimer
+	[SchemaMember("CCSBot", "m_stuckJumpTimer")]
+	public CountdownTimer StuckJumpTimer => Schema.GetDeclaredClass<CountdownTimer>(this.Handle, "CCSBot", "m_stuckJumpTimer");
+
+	// m_nextCleanupCheckTimestamp
+	[SchemaMember("CCSBot", "m_nextCleanupCheckTimestamp")]
+	public ref float NextCleanupCheckTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_nextCleanupCheckTimestamp");
+
+	// m_avgVel
+	[SchemaMember("CCSBot", "m_avgVel")]
+	public Span<float> AvgVel => Schema.GetFixedArray<float>(this.Handle, "CCSBot", "m_avgVel", 10);
+
+	// m_avgVelIndex
+	[SchemaMember("CCSBot", "m_avgVelIndex")]
+	public ref Int32 AvgVelIndex => ref Schema.GetRef<Int32>(this.Handle, "CCSBot", "m_avgVelIndex");
+
+	// m_avgVelCount
+	[SchemaMember("CCSBot", "m_avgVelCount")]
+	public ref Int32 AvgVelCount => ref Schema.GetRef<Int32>(this.Handle, "CCSBot", "m_avgVelCount");
+
+	// m_lastOrigin
+	[SchemaMember("CCSBot", "m_lastOrigin")]
+	public Vector LastOrigin => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSBot", "m_lastOrigin");
+
+	// m_lastRadioRecievedTimestamp
+	[SchemaMember("CCSBot", "m_lastRadioRecievedTimestamp")]
+	public ref float LastRadioRecievedTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_lastRadioRecievedTimestamp");
+
+	// m_lastRadioSentTimestamp
+	[SchemaMember("CCSBot", "m_lastRadioSentTimestamp")]
+	public ref float LastRadioSentTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_lastRadioSentTimestamp");
+
+	// m_radioSubject
+	[SchemaMember("CCSBot", "m_radioSubject")]
+	public CHandle<CCSPlayerPawn> RadioSubject => Schema.GetDeclaredClass<CHandle<CCSPlayerPawn>>(this.Handle, "CCSBot", "m_radioSubject");
+
+	// m_radioPosition
+	[SchemaMember("CCSBot", "m_radioPosition")]
+	public Vector RadioPosition => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSBot", "m_radioPosition");
+
+	// m_voiceEndTimestamp
+	[SchemaMember("CCSBot", "m_voiceEndTimestamp")]
+	public ref float VoiceEndTimestamp => ref Schema.GetRef<float>(this.Handle, "CCSBot", "m_voiceEndTimestamp");
+
+	// m_lastValidReactionQueueFrame
+	[SchemaMember("CCSBot", "m_lastValidReactionQueueFrame")]
+	public ref Int32 LastValidReactionQueueFrame => ref Schema.GetRef<Int32>(this.Handle, "CCSBot", "m_lastValidReactionQueueFrame");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGOViewModel.g.cs

@@ -0,0 +1,33 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGOViewModel : CPredictedViewModel
+{
+    public CCSGOViewModel (IntPtr pointer) : base(pointer) {}
+
+	// m_bShouldIgnoreOffsetAndAccuracy
+	[SchemaMember("CCSGOViewModel", "m_bShouldIgnoreOffsetAndAccuracy")]
+	public ref bool ShouldIgnoreOffsetAndAccuracy => ref Schema.GetRef<bool>(this.Handle, "CCSGOViewModel", "m_bShouldIgnoreOffsetAndAccuracy");
+
+	// m_nWeaponParity
+	[SchemaMember("CCSGOViewModel", "m_nWeaponParity")]
+	public ref UInt32 WeaponParity => ref Schema.GetRef<UInt32>(this.Handle, "CCSGOViewModel", "m_nWeaponParity");
+
+	// m_nOldWeaponParity
+	[SchemaMember("CCSGOViewModel", "m_nOldWeaponParity")]
+	public ref UInt32 OldWeaponParity => ref Schema.GetRef<UInt32>(this.Handle, "CCSGOViewModel", "m_nOldWeaponParity");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGO_TeamIntroCharacterPosition.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGO_TeamIntroCharacterPosition : CCSGO_TeamPreviewCharacterPosition
+{
+    public CCSGO_TeamIntroCharacterPosition (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGO_TeamIntroCounterTerroristPosition.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGO_TeamIntroCounterTerroristPosition : CCSGO_TeamIntroCharacterPosition
+{
+    public CCSGO_TeamIntroCounterTerroristPosition (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGO_TeamIntroTerroristPosition.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGO_TeamIntroTerroristPosition : CCSGO_TeamIntroCharacterPosition
+{
+    public CCSGO_TeamIntroTerroristPosition (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGO_TeamPreviewCharacterPosition.g.cs

@@ -0,0 +1,57 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGO_TeamPreviewCharacterPosition : CBaseEntity
+{
+    public CCSGO_TeamPreviewCharacterPosition (IntPtr pointer) : base(pointer) {}
+
+	// m_nVariant
+	[SchemaMember("CCSGO_TeamPreviewCharacterPosition", "m_nVariant")]
+	public ref Int32 Variant => ref Schema.GetRef<Int32>(this.Handle, "CCSGO_TeamPreviewCharacterPosition", "m_nVariant");
+
+	// m_nRandom
+	[SchemaMember("CCSGO_TeamPreviewCharacterPosition", "m_nRandom")]
+	public ref Int32 Random => ref Schema.GetRef<Int32>(this.Handle, "CCSGO_TeamPreviewCharacterPosition", "m_nRandom");
+
+	// m_nOrdinal
+	[SchemaMember("CCSGO_TeamPreviewCharacterPosition", "m_nOrdinal")]
+	public ref Int32 Ordinal => ref Schema.GetRef<Int32>(this.Handle, "CCSGO_TeamPreviewCharacterPosition", "m_nOrdinal");
+
+	// m_sWeaponName
+	[SchemaMember("CCSGO_TeamPreviewCharacterPosition", "m_sWeaponName")]
+	public string WeaponName
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CCSGO_TeamPreviewCharacterPosition", "m_sWeaponName"); }
+		set { Schema.SetString(this.Handle, "CCSGO_TeamPreviewCharacterPosition", "m_sWeaponName", value); }
+	}
+
+	// m_xuid
+	[SchemaMember("CCSGO_TeamPreviewCharacterPosition", "m_xuid")]
+	public ref UInt64 Xuid => ref Schema.GetRef<UInt64>(this.Handle, "CCSGO_TeamPreviewCharacterPosition", "m_xuid");
+
+	// m_agentItem
+	[SchemaMember("CCSGO_TeamPreviewCharacterPosition", "m_agentItem")]
+	public CEconItemView AgentItem => Schema.GetDeclaredClass<CEconItemView>(this.Handle, "CCSGO_TeamPreviewCharacterPosition", "m_agentItem");
+
+	// m_glovesItem
+	[SchemaMember("CCSGO_TeamPreviewCharacterPosition", "m_glovesItem")]
+	public CEconItemView GlovesItem => Schema.GetDeclaredClass<CEconItemView>(this.Handle, "CCSGO_TeamPreviewCharacterPosition", "m_glovesItem");
+
+	// m_weaponItem
+	[SchemaMember("CCSGO_TeamPreviewCharacterPosition", "m_weaponItem")]
+	public CEconItemView WeaponItem => Schema.GetDeclaredClass<CEconItemView>(this.Handle, "CCSGO_TeamPreviewCharacterPosition", "m_weaponItem");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGO_TeamSelectCharacterPosition.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGO_TeamSelectCharacterPosition : CCSGO_TeamPreviewCharacterPosition
+{
+    public CCSGO_TeamSelectCharacterPosition (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGO_TeamSelectCounterTerroristPosition.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGO_TeamSelectCounterTerroristPosition : CCSGO_TeamSelectCharacterPosition
+{
+    public CCSGO_TeamSelectCounterTerroristPosition (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGO_TeamSelectTerroristPosition.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGO_TeamSelectTerroristPosition : CCSGO_TeamSelectCharacterPosition
+{
+    public CCSGO_TeamSelectTerroristPosition (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGO_WingmanIntroCharacterPosition.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGO_WingmanIntroCharacterPosition : CCSGO_TeamIntroCharacterPosition
+{
+    public CCSGO_WingmanIntroCharacterPosition (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGO_WingmanIntroCounterTerroristPosition.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGO_WingmanIntroCounterTerroristPosition : CCSGO_WingmanIntroCharacterPosition
+{
+    public CCSGO_WingmanIntroCounterTerroristPosition (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGO_WingmanIntroTerroristPosition.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGO_WingmanIntroTerroristPosition : CCSGO_WingmanIntroCharacterPosition
+{
+    public CCSGO_WingmanIntroTerroristPosition (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGameModeRules.g.cs

@@ -0,0 +1,25 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGameModeRules : NativeObject
+{
+    public CCSGameModeRules (IntPtr pointer) : base(pointer) {}
+
+	// __m_pChainEntity
+	[SchemaMember("CCSGameModeRules", "__m_pChainEntity")]
+	public CNetworkVarChainer __m_pChainEntity => Schema.GetDeclaredClass<CNetworkVarChainer>(this.Handle, "CCSGameModeRules", "__m_pChainEntity");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGameModeRules_ArmsRace.g.cs

@@ -0,0 +1,25 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGameModeRules_ArmsRace : CCSGameModeRules
+{
+    public CCSGameModeRules_ArmsRace (IntPtr pointer) : base(pointer) {}
+
+	// m_WeaponSequence
+	[SchemaMember("CCSGameModeRules_ArmsRace", "m_WeaponSequence")]
+	public NetworkedVector<string> WeaponSequence => Schema.GetDeclaredClass<NetworkedVector<string>>(this.Handle, "CCSGameModeRules_ArmsRace", "m_WeaponSequence");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGameModeRules_Deathmatch.g.cs

@@ -0,0 +1,33 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGameModeRules_Deathmatch : CCSGameModeRules
+{
+    public CCSGameModeRules_Deathmatch (IntPtr pointer) : base(pointer) {}
+
+	// m_flDMBonusStartTime
+	[SchemaMember("CCSGameModeRules_Deathmatch", "m_flDMBonusStartTime")]
+	public ref float DMBonusStartTime => ref Schema.GetRef<float>(this.Handle, "CCSGameModeRules_Deathmatch", "m_flDMBonusStartTime");
+
+	// m_flDMBonusTimeLength
+	[SchemaMember("CCSGameModeRules_Deathmatch", "m_flDMBonusTimeLength")]
+	public ref float DMBonusTimeLength => ref Schema.GetRef<float>(this.Handle, "CCSGameModeRules_Deathmatch", "m_flDMBonusTimeLength");
+
+	// m_nDMBonusWeaponLoadoutSlot
+	[SchemaMember("CCSGameModeRules_Deathmatch", "m_nDMBonusWeaponLoadoutSlot")]
+	public ref Int16 DMBonusWeaponLoadoutSlot => ref Schema.GetRef<Int16>(this.Handle, "CCSGameModeRules_Deathmatch", "m_nDMBonusWeaponLoadoutSlot");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGameModeRules_Noop.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGameModeRules_Noop : CCSGameModeRules
+{
+    public CCSGameModeRules_Noop (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGameRules.g.cs

@@ -0,0 +1,893 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGameRules : CTeamplayRules
+{
+    public CCSGameRules (IntPtr pointer) : base(pointer) {}
+
+	// __m_pChainEntity
+	[SchemaMember("CCSGameRules", "__m_pChainEntity")]
+	public CNetworkVarChainer __m_pChainEntity => Schema.GetDeclaredClass<CNetworkVarChainer>(this.Handle, "CCSGameRules", "__m_pChainEntity");
+
+	// m_coopMissionManager
+	[SchemaMember("CCSGameRules", "m_coopMissionManager")]
+	public CHandle<CBaseEntity> CoopMissionManager => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CCSGameRules", "m_coopMissionManager");
+
+	// m_bFreezePeriod
+	[SchemaMember("CCSGameRules", "m_bFreezePeriod")]
+	public ref bool FreezePeriod => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bFreezePeriod");
+
+	// m_bWarmupPeriod
+	[SchemaMember("CCSGameRules", "m_bWarmupPeriod")]
+	public ref bool WarmupPeriod => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bWarmupPeriod");
+
+	// m_fWarmupPeriodEnd
+	[SchemaMember("CCSGameRules", "m_fWarmupPeriodEnd")]
+	public ref float WarmupPeriodEnd => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_fWarmupPeriodEnd");
+
+	// m_fWarmupPeriodStart
+	[SchemaMember("CCSGameRules", "m_fWarmupPeriodStart")]
+	public ref float WarmupPeriodStart => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_fWarmupPeriodStart");
+
+	// m_nTotalPausedTicks
+	[SchemaMember("CCSGameRules", "m_nTotalPausedTicks")]
+	public ref Int32 TotalPausedTicks => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nTotalPausedTicks");
+
+	// m_nPauseStartTick
+	[SchemaMember("CCSGameRules", "m_nPauseStartTick")]
+	public ref Int32 PauseStartTick => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nPauseStartTick");
+
+	// m_bServerPaused
+	[SchemaMember("CCSGameRules", "m_bServerPaused")]
+	public ref bool ServerPaused => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bServerPaused");
+
+	// m_bGamePaused
+	[SchemaMember("CCSGameRules", "m_bGamePaused")]
+	public ref bool GamePaused => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bGamePaused");
+
+	// m_bTerroristTimeOutActive
+	[SchemaMember("CCSGameRules", "m_bTerroristTimeOutActive")]
+	public ref bool TerroristTimeOutActive => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bTerroristTimeOutActive");
+
+	// m_bCTTimeOutActive
+	[SchemaMember("CCSGameRules", "m_bCTTimeOutActive")]
+	public ref bool CTTimeOutActive => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bCTTimeOutActive");
+
+	// m_flTerroristTimeOutRemaining
+	[SchemaMember("CCSGameRules", "m_flTerroristTimeOutRemaining")]
+	public ref float TerroristTimeOutRemaining => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flTerroristTimeOutRemaining");
+
+	// m_flCTTimeOutRemaining
+	[SchemaMember("CCSGameRules", "m_flCTTimeOutRemaining")]
+	public ref float CTTimeOutRemaining => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flCTTimeOutRemaining");
+
+	// m_nTerroristTimeOuts
+	[SchemaMember("CCSGameRules", "m_nTerroristTimeOuts")]
+	public ref Int32 TerroristTimeOuts => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nTerroristTimeOuts");
+
+	// m_nCTTimeOuts
+	[SchemaMember("CCSGameRules", "m_nCTTimeOuts")]
+	public ref Int32 CTTimeOuts => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nCTTimeOuts");
+
+	// m_bTechnicalTimeOut
+	[SchemaMember("CCSGameRules", "m_bTechnicalTimeOut")]
+	public ref bool TechnicalTimeOut => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bTechnicalTimeOut");
+
+	// m_bMatchWaitingForResume
+	[SchemaMember("CCSGameRules", "m_bMatchWaitingForResume")]
+	public ref bool MatchWaitingForResume => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bMatchWaitingForResume");
+
+	// m_iRoundTime
+	[SchemaMember("CCSGameRules", "m_iRoundTime")]
+	public ref Int32 RoundTime => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iRoundTime");
+
+	// m_fMatchStartTime
+	[SchemaMember("CCSGameRules", "m_fMatchStartTime")]
+	public ref float MatchStartTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_fMatchStartTime");
+
+	// m_fRoundStartTime
+	[SchemaMember("CCSGameRules", "m_fRoundStartTime")]
+	public ref float RoundStartTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_fRoundStartTime");
+
+	// m_flRestartRoundTime
+	[SchemaMember("CCSGameRules", "m_flRestartRoundTime")]
+	public ref float RestartRoundTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flRestartRoundTime");
+
+	// m_bGameRestart
+	[SchemaMember("CCSGameRules", "m_bGameRestart")]
+	public ref bool GameRestart => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bGameRestart");
+
+	// m_flGameStartTime
+	[SchemaMember("CCSGameRules", "m_flGameStartTime")]
+	public ref float GameStartTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flGameStartTime");
+
+	// m_timeUntilNextPhaseStarts
+	[SchemaMember("CCSGameRules", "m_timeUntilNextPhaseStarts")]
+	public ref float TimeUntilNextPhaseStarts => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_timeUntilNextPhaseStarts");
+
+	// m_gamePhase
+	[SchemaMember("CCSGameRules", "m_gamePhase")]
+	public ref Int32 GamePhase => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_gamePhase");
+
+	// m_totalRoundsPlayed
+	[SchemaMember("CCSGameRules", "m_totalRoundsPlayed")]
+	public ref Int32 TotalRoundsPlayed => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_totalRoundsPlayed");
+
+	// m_nRoundsPlayedThisPhase
+	[SchemaMember("CCSGameRules", "m_nRoundsPlayedThisPhase")]
+	public ref Int32 RoundsPlayedThisPhase => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nRoundsPlayedThisPhase");
+
+	// m_nOvertimePlaying
+	[SchemaMember("CCSGameRules", "m_nOvertimePlaying")]
+	public ref Int32 OvertimePlaying => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nOvertimePlaying");
+
+	// m_iHostagesRemaining
+	[SchemaMember("CCSGameRules", "m_iHostagesRemaining")]
+	public ref Int32 HostagesRemaining => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iHostagesRemaining");
+
+	// m_bAnyHostageReached
+	[SchemaMember("CCSGameRules", "m_bAnyHostageReached")]
+	public ref bool AnyHostageReached => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bAnyHostageReached");
+
+	// m_bMapHasBombTarget
+	[SchemaMember("CCSGameRules", "m_bMapHasBombTarget")]
+	public ref bool MapHasBombTarget => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bMapHasBombTarget");
+
+	// m_bMapHasRescueZone
+	[SchemaMember("CCSGameRules", "m_bMapHasRescueZone")]
+	public ref bool MapHasRescueZone => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bMapHasRescueZone");
+
+	// m_bMapHasBuyZone
+	[SchemaMember("CCSGameRules", "m_bMapHasBuyZone")]
+	public ref bool MapHasBuyZone => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bMapHasBuyZone");
+
+	// m_bIsQueuedMatchmaking
+	[SchemaMember("CCSGameRules", "m_bIsQueuedMatchmaking")]
+	public ref bool IsQueuedMatchmaking => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bIsQueuedMatchmaking");
+
+	// m_nQueuedMatchmakingMode
+	[SchemaMember("CCSGameRules", "m_nQueuedMatchmakingMode")]
+	public ref Int32 QueuedMatchmakingMode => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nQueuedMatchmakingMode");
+
+	// m_bIsValveDS
+	[SchemaMember("CCSGameRules", "m_bIsValveDS")]
+	public ref bool IsValveDS => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bIsValveDS");
+
+	// m_bLogoMap
+	[SchemaMember("CCSGameRules", "m_bLogoMap")]
+	public ref bool LogoMap => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bLogoMap");
+
+	// m_bPlayAllStepSoundsOnServer
+	[SchemaMember("CCSGameRules", "m_bPlayAllStepSoundsOnServer")]
+	public ref bool PlayAllStepSoundsOnServer => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bPlayAllStepSoundsOnServer");
+
+	// m_iSpectatorSlotCount
+	[SchemaMember("CCSGameRules", "m_iSpectatorSlotCount")]
+	public ref Int32 SpectatorSlotCount => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iSpectatorSlotCount");
+
+	// m_MatchDevice
+	[SchemaMember("CCSGameRules", "m_MatchDevice")]
+	public ref Int32 MatchDevice => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_MatchDevice");
+
+	// m_bHasMatchStarted
+	[SchemaMember("CCSGameRules", "m_bHasMatchStarted")]
+	public ref bool HasMatchStarted => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bHasMatchStarted");
+
+	// m_nNextMapInMapgroup
+	[SchemaMember("CCSGameRules", "m_nNextMapInMapgroup")]
+	public ref Int32 NextMapInMapgroup => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nNextMapInMapgroup");
+
+	// m_szTournamentEventName
+	[SchemaMember("CCSGameRules", "m_szTournamentEventName")]
+	public string TournamentEventName
+	{
+		get { return Schema.GetString(this.Handle, "CCSGameRules", "m_szTournamentEventName"); }
+		set { Schema.SetString(this.Handle, "CCSGameRules", "m_szTournamentEventName", value); }
+	}
+
+	// m_szTournamentEventStage
+	[SchemaMember("CCSGameRules", "m_szTournamentEventStage")]
+	public string TournamentEventStage
+	{
+		get { return Schema.GetString(this.Handle, "CCSGameRules", "m_szTournamentEventStage"); }
+		set { Schema.SetString(this.Handle, "CCSGameRules", "m_szTournamentEventStage", value); }
+	}
+
+	// m_szMatchStatTxt
+	[SchemaMember("CCSGameRules", "m_szMatchStatTxt")]
+	public string MatchStatTxt
+	{
+		get { return Schema.GetString(this.Handle, "CCSGameRules", "m_szMatchStatTxt"); }
+		set { Schema.SetString(this.Handle, "CCSGameRules", "m_szMatchStatTxt", value); }
+	}
+
+	// m_szTournamentPredictionsTxt
+	[SchemaMember("CCSGameRules", "m_szTournamentPredictionsTxt")]
+	public string TournamentPredictionsTxt
+	{
+		get { return Schema.GetString(this.Handle, "CCSGameRules", "m_szTournamentPredictionsTxt"); }
+		set { Schema.SetString(this.Handle, "CCSGameRules", "m_szTournamentPredictionsTxt", value); }
+	}
+
+	// m_nTournamentPredictionsPct
+	[SchemaMember("CCSGameRules", "m_nTournamentPredictionsPct")]
+	public ref Int32 TournamentPredictionsPct => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nTournamentPredictionsPct");
+
+	// m_flCMMItemDropRevealStartTime
+	[SchemaMember("CCSGameRules", "m_flCMMItemDropRevealStartTime")]
+	public ref float CMMItemDropRevealStartTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flCMMItemDropRevealStartTime");
+
+	// m_flCMMItemDropRevealEndTime
+	[SchemaMember("CCSGameRules", "m_flCMMItemDropRevealEndTime")]
+	public ref float CMMItemDropRevealEndTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flCMMItemDropRevealEndTime");
+
+	// m_bIsDroppingItems
+	[SchemaMember("CCSGameRules", "m_bIsDroppingItems")]
+	public ref bool IsDroppingItems => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bIsDroppingItems");
+
+	// m_bIsQuestEligible
+	[SchemaMember("CCSGameRules", "m_bIsQuestEligible")]
+	public ref bool IsQuestEligible => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bIsQuestEligible");
+
+	// m_bIsHltvActive
+	[SchemaMember("CCSGameRules", "m_bIsHltvActive")]
+	public ref bool IsHltvActive => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bIsHltvActive");
+
+	// m_nGuardianModeWaveNumber
+	[SchemaMember("CCSGameRules", "m_nGuardianModeWaveNumber")]
+	public ref Int32 GuardianModeWaveNumber => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nGuardianModeWaveNumber");
+
+	// m_nGuardianModeSpecialKillsRemaining
+	[SchemaMember("CCSGameRules", "m_nGuardianModeSpecialKillsRemaining")]
+	public ref Int32 GuardianModeSpecialKillsRemaining => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nGuardianModeSpecialKillsRemaining");
+
+	// m_nGuardianModeSpecialWeaponNeeded
+	[SchemaMember("CCSGameRules", "m_nGuardianModeSpecialWeaponNeeded")]
+	public ref Int32 GuardianModeSpecialWeaponNeeded => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nGuardianModeSpecialWeaponNeeded");
+
+	// m_nGuardianGrenadesToGiveBots
+	[SchemaMember("CCSGameRules", "m_nGuardianGrenadesToGiveBots")]
+	public ref Int32 GuardianGrenadesToGiveBots => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nGuardianGrenadesToGiveBots");
+
+	// m_nNumHeaviesToSpawn
+	[SchemaMember("CCSGameRules", "m_nNumHeaviesToSpawn")]
+	public ref Int32 NumHeaviesToSpawn => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nNumHeaviesToSpawn");
+
+	// m_numGlobalGiftsGiven
+	[SchemaMember("CCSGameRules", "m_numGlobalGiftsGiven")]
+	public ref UInt32 NumGlobalGiftsGiven => ref Schema.GetRef<UInt32>(this.Handle, "CCSGameRules", "m_numGlobalGiftsGiven");
+
+	// m_numGlobalGifters
+	[SchemaMember("CCSGameRules", "m_numGlobalGifters")]
+	public ref UInt32 NumGlobalGifters => ref Schema.GetRef<UInt32>(this.Handle, "CCSGameRules", "m_numGlobalGifters");
+
+	// m_numGlobalGiftsPeriodSeconds
+	[SchemaMember("CCSGameRules", "m_numGlobalGiftsPeriodSeconds")]
+	public ref UInt32 NumGlobalGiftsPeriodSeconds => ref Schema.GetRef<UInt32>(this.Handle, "CCSGameRules", "m_numGlobalGiftsPeriodSeconds");
+
+	// m_arrFeaturedGiftersAccounts
+	[SchemaMember("CCSGameRules", "m_arrFeaturedGiftersAccounts")]
+	public Span<UInt32> FeaturedGiftersAccounts => Schema.GetFixedArray<UInt32>(this.Handle, "CCSGameRules", "m_arrFeaturedGiftersAccounts", 4);
+
+	// m_arrFeaturedGiftersGifts
+	[SchemaMember("CCSGameRules", "m_arrFeaturedGiftersGifts")]
+	public Span<UInt32> FeaturedGiftersGifts => Schema.GetFixedArray<UInt32>(this.Handle, "CCSGameRules", "m_arrFeaturedGiftersGifts", 4);
+
+	// m_arrProhibitedItemIndices
+	[SchemaMember("CCSGameRules", "m_arrProhibitedItemIndices")]
+	public Span<UInt16> ProhibitedItemIndices => Schema.GetFixedArray<UInt16>(this.Handle, "CCSGameRules", "m_arrProhibitedItemIndices", 100);
+
+	// m_arrTournamentActiveCasterAccounts
+	[SchemaMember("CCSGameRules", "m_arrTournamentActiveCasterAccounts")]
+	public Span<UInt32> TournamentActiveCasterAccounts => Schema.GetFixedArray<UInt32>(this.Handle, "CCSGameRules", "m_arrTournamentActiveCasterAccounts", 4);
+
+	// m_numBestOfMaps
+	[SchemaMember("CCSGameRules", "m_numBestOfMaps")]
+	public ref Int32 NumBestOfMaps => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_numBestOfMaps");
+
+	// m_nHalloweenMaskListSeed
+	[SchemaMember("CCSGameRules", "m_nHalloweenMaskListSeed")]
+	public ref Int32 HalloweenMaskListSeed => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nHalloweenMaskListSeed");
+
+	// m_bBombDropped
+	[SchemaMember("CCSGameRules", "m_bBombDropped")]
+	public ref bool BombDropped => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bBombDropped");
+
+	// m_bBombPlanted
+	[SchemaMember("CCSGameRules", "m_bBombPlanted")]
+	public ref bool BombPlanted => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bBombPlanted");
+
+	// m_iRoundWinStatus
+	[SchemaMember("CCSGameRules", "m_iRoundWinStatus")]
+	public ref Int32 RoundWinStatus => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iRoundWinStatus");
+
+	// m_eRoundWinReason
+	[SchemaMember("CCSGameRules", "m_eRoundWinReason")]
+	public ref Int32 RoundWinReason => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_eRoundWinReason");
+
+	// m_bTCantBuy
+	[SchemaMember("CCSGameRules", "m_bTCantBuy")]
+	public ref bool TCantBuy => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bTCantBuy");
+
+	// m_bCTCantBuy
+	[SchemaMember("CCSGameRules", "m_bCTCantBuy")]
+	public ref bool CTCantBuy => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bCTCantBuy");
+
+	// m_flGuardianBuyUntilTime
+	[SchemaMember("CCSGameRules", "m_flGuardianBuyUntilTime")]
+	public ref float GuardianBuyUntilTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flGuardianBuyUntilTime");
+
+	// m_iMatchStats_RoundResults
+	[SchemaMember("CCSGameRules", "m_iMatchStats_RoundResults")]
+	public Span<Int32> MatchStats_RoundResults => Schema.GetFixedArray<Int32>(this.Handle, "CCSGameRules", "m_iMatchStats_RoundResults", 30);
+
+	// m_iMatchStats_PlayersAlive_CT
+	[SchemaMember("CCSGameRules", "m_iMatchStats_PlayersAlive_CT")]
+	public Span<Int32> MatchStats_PlayersAlive_CT => Schema.GetFixedArray<Int32>(this.Handle, "CCSGameRules", "m_iMatchStats_PlayersAlive_CT", 30);
+
+	// m_iMatchStats_PlayersAlive_T
+	[SchemaMember("CCSGameRules", "m_iMatchStats_PlayersAlive_T")]
+	public Span<Int32> MatchStats_PlayersAlive_T => Schema.GetFixedArray<Int32>(this.Handle, "CCSGameRules", "m_iMatchStats_PlayersAlive_T", 30);
+
+	// m_TeamRespawnWaveTimes
+	[SchemaMember("CCSGameRules", "m_TeamRespawnWaveTimes")]
+	public Span<float> TeamRespawnWaveTimes => Schema.GetFixedArray<float>(this.Handle, "CCSGameRules", "m_TeamRespawnWaveTimes", 32);
+
+	// m_flNextRespawnWave
+	[SchemaMember("CCSGameRules", "m_flNextRespawnWave")]
+	public Span<float> NextRespawnWave => Schema.GetFixedArray<float>(this.Handle, "CCSGameRules", "m_flNextRespawnWave", 32);
+
+	// m_nServerQuestID
+	[SchemaMember("CCSGameRules", "m_nServerQuestID")]
+	public ref Int32 ServerQuestID => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nServerQuestID");
+
+	// m_vMinimapMins
+	[SchemaMember("CCSGameRules", "m_vMinimapMins")]
+	public Vector MinimapMins => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSGameRules", "m_vMinimapMins");
+
+	// m_vMinimapMaxs
+	[SchemaMember("CCSGameRules", "m_vMinimapMaxs")]
+	public Vector MinimapMaxs => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSGameRules", "m_vMinimapMaxs");
+
+	// m_MinimapVerticalSectionHeights
+	[SchemaMember("CCSGameRules", "m_MinimapVerticalSectionHeights")]
+	public Span<float> MinimapVerticalSectionHeights => Schema.GetFixedArray<float>(this.Handle, "CCSGameRules", "m_MinimapVerticalSectionHeights", 8);
+
+	// m_bDontIncrementCoopWave
+	[SchemaMember("CCSGameRules", "m_bDontIncrementCoopWave")]
+	public ref bool DontIncrementCoopWave => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bDontIncrementCoopWave");
+
+	// m_bSpawnedTerrorHuntHeavy
+	[SchemaMember("CCSGameRules", "m_bSpawnedTerrorHuntHeavy")]
+	public ref bool SpawnedTerrorHuntHeavy => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bSpawnedTerrorHuntHeavy");
+
+	// m_nEndMatchMapGroupVoteTypes
+	[SchemaMember("CCSGameRules", "m_nEndMatchMapGroupVoteTypes")]
+	public Span<Int32> EndMatchMapGroupVoteTypes => Schema.GetFixedArray<Int32>(this.Handle, "CCSGameRules", "m_nEndMatchMapGroupVoteTypes", 10);
+
+	// m_nEndMatchMapGroupVoteOptions
+	[SchemaMember("CCSGameRules", "m_nEndMatchMapGroupVoteOptions")]
+	public Span<Int32> EndMatchMapGroupVoteOptions => Schema.GetFixedArray<Int32>(this.Handle, "CCSGameRules", "m_nEndMatchMapGroupVoteOptions", 10);
+
+	// m_nEndMatchMapVoteWinner
+	[SchemaMember("CCSGameRules", "m_nEndMatchMapVoteWinner")]
+	public ref Int32 EndMatchMapVoteWinner => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nEndMatchMapVoteWinner");
+
+	// m_iNumConsecutiveCTLoses
+	[SchemaMember("CCSGameRules", "m_iNumConsecutiveCTLoses")]
+	public ref Int32 NumConsecutiveCTLoses => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iNumConsecutiveCTLoses");
+
+	// m_iNumConsecutiveTerroristLoses
+	[SchemaMember("CCSGameRules", "m_iNumConsecutiveTerroristLoses")]
+	public ref Int32 NumConsecutiveTerroristLoses => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iNumConsecutiveTerroristLoses");
+
+	// m_bHasHostageBeenTouched
+	[SchemaMember("CCSGameRules", "m_bHasHostageBeenTouched")]
+	public ref bool HasHostageBeenTouched => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bHasHostageBeenTouched");
+
+	// m_flIntermissionStartTime
+	[SchemaMember("CCSGameRules", "m_flIntermissionStartTime")]
+	public ref float IntermissionStartTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flIntermissionStartTime");
+
+	// m_flIntermissionEndTime
+	[SchemaMember("CCSGameRules", "m_flIntermissionEndTime")]
+	public ref float IntermissionEndTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flIntermissionEndTime");
+
+	// m_bLevelInitialized
+	[SchemaMember("CCSGameRules", "m_bLevelInitialized")]
+	public ref bool LevelInitialized => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bLevelInitialized");
+
+	// m_iTotalRoundsPlayed
+	[SchemaMember("CCSGameRules", "m_iTotalRoundsPlayed")]
+	public ref Int32 ITotalRoundsPlayed => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iTotalRoundsPlayed");
+
+	// m_iUnBalancedRounds
+	[SchemaMember("CCSGameRules", "m_iUnBalancedRounds")]
+	public ref Int32 UnBalancedRounds => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iUnBalancedRounds");
+
+	// m_endMatchOnRoundReset
+	[SchemaMember("CCSGameRules", "m_endMatchOnRoundReset")]
+	public ref bool EndMatchOnRoundReset => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_endMatchOnRoundReset");
+
+	// m_endMatchOnThink
+	[SchemaMember("CCSGameRules", "m_endMatchOnThink")]
+	public ref bool EndMatchOnThink => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_endMatchOnThink");
+
+	// m_iFreezeTime
+	[SchemaMember("CCSGameRules", "m_iFreezeTime")]
+	public ref Int32 FreezeTime => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iFreezeTime");
+
+	// m_iNumTerrorist
+	[SchemaMember("CCSGameRules", "m_iNumTerrorist")]
+	public ref Int32 NumTerrorist => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iNumTerrorist");
+
+	// m_iNumCT
+	[SchemaMember("CCSGameRules", "m_iNumCT")]
+	public ref Int32 NumCT => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iNumCT");
+
+	// m_iNumSpawnableTerrorist
+	[SchemaMember("CCSGameRules", "m_iNumSpawnableTerrorist")]
+	public ref Int32 NumSpawnableTerrorist => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iNumSpawnableTerrorist");
+
+	// m_iNumSpawnableCT
+	[SchemaMember("CCSGameRules", "m_iNumSpawnableCT")]
+	public ref Int32 NumSpawnableCT => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iNumSpawnableCT");
+
+	// m_arrSelectedHostageSpawnIndices
+	[SchemaMember("CCSGameRules", "m_arrSelectedHostageSpawnIndices")]
+	public NetworkedVector<Int32> SelectedHostageSpawnIndices => Schema.GetDeclaredClass<NetworkedVector<Int32>>(this.Handle, "CCSGameRules", "m_arrSelectedHostageSpawnIndices");
+
+	// m_bFirstConnected
+	[SchemaMember("CCSGameRules", "m_bFirstConnected")]
+	public ref bool FirstConnected => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bFirstConnected");
+
+	// m_bCompleteReset
+	[SchemaMember("CCSGameRules", "m_bCompleteReset")]
+	public ref bool CompleteReset => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bCompleteReset");
+
+	// m_bPickNewTeamsOnReset
+	[SchemaMember("CCSGameRules", "m_bPickNewTeamsOnReset")]
+	public ref bool PickNewTeamsOnReset => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bPickNewTeamsOnReset");
+
+	// m_bScrambleTeamsOnRestart
+	[SchemaMember("CCSGameRules", "m_bScrambleTeamsOnRestart")]
+	public ref bool ScrambleTeamsOnRestart => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bScrambleTeamsOnRestart");
+
+	// m_bSwapTeamsOnRestart
+	[SchemaMember("CCSGameRules", "m_bSwapTeamsOnRestart")]
+	public ref bool SwapTeamsOnRestart => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bSwapTeamsOnRestart");
+
+	// m_nEndMatchTiedVotes
+	[SchemaMember("CCSGameRules", "m_nEndMatchTiedVotes")]
+	public NetworkedVector<Int32> EndMatchTiedVotes => Schema.GetDeclaredClass<NetworkedVector<Int32>>(this.Handle, "CCSGameRules", "m_nEndMatchTiedVotes");
+
+	// m_bNeedToAskPlayersForContinueVote
+	[SchemaMember("CCSGameRules", "m_bNeedToAskPlayersForContinueVote")]
+	public ref bool NeedToAskPlayersForContinueVote => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bNeedToAskPlayersForContinueVote");
+
+	// m_numQueuedMatchmakingAccounts
+	[SchemaMember("CCSGameRules", "m_numQueuedMatchmakingAccounts")]
+	public ref UInt32 NumQueuedMatchmakingAccounts => ref Schema.GetRef<UInt32>(this.Handle, "CCSGameRules", "m_numQueuedMatchmakingAccounts");
+
+	// m_pQueuedMatchmakingReservationString
+	[SchemaMember("CCSGameRules", "m_pQueuedMatchmakingReservationString")]
+	public string QueuedMatchmakingReservationString
+	{
+		get { return Schema.GetString(this.Handle, "CCSGameRules", "m_pQueuedMatchmakingReservationString"); }
+		set { Schema.SetString(this.Handle, "CCSGameRules", "m_pQueuedMatchmakingReservationString", value); }
+	}
+
+	// m_numTotalTournamentDrops
+	[SchemaMember("CCSGameRules", "m_numTotalTournamentDrops")]
+	public ref UInt32 NumTotalTournamentDrops => ref Schema.GetRef<UInt32>(this.Handle, "CCSGameRules", "m_numTotalTournamentDrops");
+
+	// m_numSpectatorsCountMax
+	[SchemaMember("CCSGameRules", "m_numSpectatorsCountMax")]
+	public ref UInt32 NumSpectatorsCountMax => ref Schema.GetRef<UInt32>(this.Handle, "CCSGameRules", "m_numSpectatorsCountMax");
+
+	// m_numSpectatorsCountMaxTV
+	[SchemaMember("CCSGameRules", "m_numSpectatorsCountMaxTV")]
+	public ref UInt32 NumSpectatorsCountMaxTV => ref Schema.GetRef<UInt32>(this.Handle, "CCSGameRules", "m_numSpectatorsCountMaxTV");
+
+	// m_numSpectatorsCountMaxLnk
+	[SchemaMember("CCSGameRules", "m_numSpectatorsCountMaxLnk")]
+	public ref UInt32 NumSpectatorsCountMaxLnk => ref Schema.GetRef<UInt32>(this.Handle, "CCSGameRules", "m_numSpectatorsCountMaxLnk");
+
+	// m_bForceTeamChangeSilent
+	[SchemaMember("CCSGameRules", "m_bForceTeamChangeSilent")]
+	public ref bool ForceTeamChangeSilent => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bForceTeamChangeSilent");
+
+	// m_bLoadingRoundBackupData
+	[SchemaMember("CCSGameRules", "m_bLoadingRoundBackupData")]
+	public ref bool LoadingRoundBackupData => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bLoadingRoundBackupData");
+
+	// m_nMatchInfoShowType
+	[SchemaMember("CCSGameRules", "m_nMatchInfoShowType")]
+	public ref Int32 MatchInfoShowType => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nMatchInfoShowType");
+
+	// m_flMatchInfoDecidedTime
+	[SchemaMember("CCSGameRules", "m_flMatchInfoDecidedTime")]
+	public ref float MatchInfoDecidedTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flMatchInfoDecidedTime");
+
+	// m_flCoopRespawnAndHealTime
+	[SchemaMember("CCSGameRules", "m_flCoopRespawnAndHealTime")]
+	public ref float CoopRespawnAndHealTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flCoopRespawnAndHealTime");
+
+	// m_coopBonusCoinsFound
+	[SchemaMember("CCSGameRules", "m_coopBonusCoinsFound")]
+	public ref Int32 CoopBonusCoinsFound => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_coopBonusCoinsFound");
+
+	// m_coopBonusPistolsOnly
+	[SchemaMember("CCSGameRules", "m_coopBonusPistolsOnly")]
+	public ref bool CoopBonusPistolsOnly => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_coopBonusPistolsOnly");
+
+	// m_coopPlayersInDeploymentZone
+	[SchemaMember("CCSGameRules", "m_coopPlayersInDeploymentZone")]
+	public ref bool CoopPlayersInDeploymentZone => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_coopPlayersInDeploymentZone");
+
+	// m_coopMissionDeadPlayerRespawnEnabled
+	[SchemaMember("CCSGameRules", "m_coopMissionDeadPlayerRespawnEnabled")]
+	public ref bool CoopMissionDeadPlayerRespawnEnabled => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_coopMissionDeadPlayerRespawnEnabled");
+
+	// mTeamDMLastWinningTeamNumber
+	[SchemaMember("CCSGameRules", "mTeamDMLastWinningTeamNumber")]
+	public ref Int32 MTeamDMLastWinningTeamNumber => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "mTeamDMLastWinningTeamNumber");
+
+	// mTeamDMLastThinkTime
+	[SchemaMember("CCSGameRules", "mTeamDMLastThinkTime")]
+	public ref float MTeamDMLastThinkTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "mTeamDMLastThinkTime");
+
+	// m_flTeamDMLastAnnouncementTime
+	[SchemaMember("CCSGameRules", "m_flTeamDMLastAnnouncementTime")]
+	public ref float TeamDMLastAnnouncementTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flTeamDMLastAnnouncementTime");
+
+	// m_iAccountTerrorist
+	[SchemaMember("CCSGameRules", "m_iAccountTerrorist")]
+	public ref Int32 AccountTerrorist => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iAccountTerrorist");
+
+	// m_iAccountCT
+	[SchemaMember("CCSGameRules", "m_iAccountCT")]
+	public ref Int32 AccountCT => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iAccountCT");
+
+	// m_iSpawnPointCount_Terrorist
+	[SchemaMember("CCSGameRules", "m_iSpawnPointCount_Terrorist")]
+	public ref Int32 SpawnPointCount_Terrorist => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iSpawnPointCount_Terrorist");
+
+	// m_iSpawnPointCount_CT
+	[SchemaMember("CCSGameRules", "m_iSpawnPointCount_CT")]
+	public ref Int32 SpawnPointCount_CT => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iSpawnPointCount_CT");
+
+	// m_iMaxNumTerrorists
+	[SchemaMember("CCSGameRules", "m_iMaxNumTerrorists")]
+	public ref Int32 MaxNumTerrorists => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iMaxNumTerrorists");
+
+	// m_iMaxNumCTs
+	[SchemaMember("CCSGameRules", "m_iMaxNumCTs")]
+	public ref Int32 MaxNumCTs => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iMaxNumCTs");
+
+	// m_iLoserBonus
+	[SchemaMember("CCSGameRules", "m_iLoserBonus")]
+	public ref Int32 LoserBonus => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iLoserBonus");
+
+	// m_iLoserBonusMostRecentTeam
+	[SchemaMember("CCSGameRules", "m_iLoserBonusMostRecentTeam")]
+	public ref Int32 LoserBonusMostRecentTeam => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iLoserBonusMostRecentTeam");
+
+	// m_tmNextPeriodicThink
+	[SchemaMember("CCSGameRules", "m_tmNextPeriodicThink")]
+	public ref float TmNextPeriodicThink => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_tmNextPeriodicThink");
+
+	// m_bVoiceWonMatchBragFired
+	[SchemaMember("CCSGameRules", "m_bVoiceWonMatchBragFired")]
+	public ref bool VoiceWonMatchBragFired => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bVoiceWonMatchBragFired");
+
+	// m_fWarmupNextChatNoticeTime
+	[SchemaMember("CCSGameRules", "m_fWarmupNextChatNoticeTime")]
+	public ref float WarmupNextChatNoticeTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_fWarmupNextChatNoticeTime");
+
+	// m_iHostagesRescued
+	[SchemaMember("CCSGameRules", "m_iHostagesRescued")]
+	public ref Int32 HostagesRescued => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iHostagesRescued");
+
+	// m_iHostagesTouched
+	[SchemaMember("CCSGameRules", "m_iHostagesTouched")]
+	public ref Int32 HostagesTouched => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iHostagesTouched");
+
+	// m_flNextHostageAnnouncement
+	[SchemaMember("CCSGameRules", "m_flNextHostageAnnouncement")]
+	public ref float NextHostageAnnouncement => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flNextHostageAnnouncement");
+
+	// m_bNoTerroristsKilled
+	[SchemaMember("CCSGameRules", "m_bNoTerroristsKilled")]
+	public ref bool NoTerroristsKilled => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bNoTerroristsKilled");
+
+	// m_bNoCTsKilled
+	[SchemaMember("CCSGameRules", "m_bNoCTsKilled")]
+	public ref bool NoCTsKilled => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bNoCTsKilled");
+
+	// m_bNoEnemiesKilled
+	[SchemaMember("CCSGameRules", "m_bNoEnemiesKilled")]
+	public ref bool NoEnemiesKilled => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bNoEnemiesKilled");
+
+	// m_bCanDonateWeapons
+	[SchemaMember("CCSGameRules", "m_bCanDonateWeapons")]
+	public ref bool CanDonateWeapons => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bCanDonateWeapons");
+
+	// m_firstKillTime
+	[SchemaMember("CCSGameRules", "m_firstKillTime")]
+	public ref float FirstKillTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_firstKillTime");
+
+	// m_firstBloodTime
+	[SchemaMember("CCSGameRules", "m_firstBloodTime")]
+	public ref float FirstBloodTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_firstBloodTime");
+
+	// m_hostageWasInjured
+	[SchemaMember("CCSGameRules", "m_hostageWasInjured")]
+	public ref bool HostageWasInjured => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_hostageWasInjured");
+
+	// m_hostageWasKilled
+	[SchemaMember("CCSGameRules", "m_hostageWasKilled")]
+	public ref bool HostageWasKilled => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_hostageWasKilled");
+
+	// m_bVoteCalled
+	[SchemaMember("CCSGameRules", "m_bVoteCalled")]
+	public ref bool VoteCalled => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bVoteCalled");
+
+	// m_bServerVoteOnReset
+	[SchemaMember("CCSGameRules", "m_bServerVoteOnReset")]
+	public ref bool ServerVoteOnReset => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bServerVoteOnReset");
+
+	// m_flVoteCheckThrottle
+	[SchemaMember("CCSGameRules", "m_flVoteCheckThrottle")]
+	public ref float VoteCheckThrottle => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flVoteCheckThrottle");
+
+	// m_bBuyTimeEnded
+	[SchemaMember("CCSGameRules", "m_bBuyTimeEnded")]
+	public ref bool BuyTimeEnded => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bBuyTimeEnded");
+
+	// m_nLastFreezeEndBeep
+	[SchemaMember("CCSGameRules", "m_nLastFreezeEndBeep")]
+	public ref Int32 LastFreezeEndBeep => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nLastFreezeEndBeep");
+
+	// m_bTargetBombed
+	[SchemaMember("CCSGameRules", "m_bTargetBombed")]
+	public ref bool TargetBombed => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bTargetBombed");
+
+	// m_bBombDefused
+	[SchemaMember("CCSGameRules", "m_bBombDefused")]
+	public ref bool BombDefused => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bBombDefused");
+
+	// m_bMapHasBombZone
+	[SchemaMember("CCSGameRules", "m_bMapHasBombZone")]
+	public ref bool MapHasBombZone => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bMapHasBombZone");
+
+	// m_vecMainCTSpawnPos
+	[SchemaMember("CCSGameRules", "m_vecMainCTSpawnPos")]
+	public Vector MainCTSpawnPos => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSGameRules", "m_vecMainCTSpawnPos");
+
+	// m_CTSpawnPointsMasterList
+	[SchemaMember("CCSGameRules", "m_CTSpawnPointsMasterList")]
+	public NetworkedVector<SpawnPoint?> CTSpawnPointsMasterList => Schema.GetDeclaredClass<NetworkedVector<SpawnPoint?>>(this.Handle, "CCSGameRules", "m_CTSpawnPointsMasterList");
+
+	// m_TerroristSpawnPointsMasterList
+	[SchemaMember("CCSGameRules", "m_TerroristSpawnPointsMasterList")]
+	public NetworkedVector<SpawnPoint?> TerroristSpawnPointsMasterList => Schema.GetDeclaredClass<NetworkedVector<SpawnPoint?>>(this.Handle, "CCSGameRules", "m_TerroristSpawnPointsMasterList");
+
+	// m_iNextCTSpawnPoint
+	[SchemaMember("CCSGameRules", "m_iNextCTSpawnPoint")]
+	public ref Int32 NextCTSpawnPoint => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iNextCTSpawnPoint");
+
+	// m_iNextTerroristSpawnPoint
+	[SchemaMember("CCSGameRules", "m_iNextTerroristSpawnPoint")]
+	public ref Int32 NextTerroristSpawnPoint => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iNextTerroristSpawnPoint");
+
+	// m_CTSpawnPoints
+	[SchemaMember("CCSGameRules", "m_CTSpawnPoints")]
+	public NetworkedVector<SpawnPoint?> CTSpawnPoints => Schema.GetDeclaredClass<NetworkedVector<SpawnPoint?>>(this.Handle, "CCSGameRules", "m_CTSpawnPoints");
+
+	// m_TerroristSpawnPoints
+	[SchemaMember("CCSGameRules", "m_TerroristSpawnPoints")]
+	public NetworkedVector<SpawnPoint?> TerroristSpawnPoints => Schema.GetDeclaredClass<NetworkedVector<SpawnPoint?>>(this.Handle, "CCSGameRules", "m_TerroristSpawnPoints");
+
+	// m_bIsUnreservedGameServer
+	[SchemaMember("CCSGameRules", "m_bIsUnreservedGameServer")]
+	public ref bool IsUnreservedGameServer => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bIsUnreservedGameServer");
+
+	// m_fAutobalanceDisplayTime
+	[SchemaMember("CCSGameRules", "m_fAutobalanceDisplayTime")]
+	public ref float AutobalanceDisplayTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_fAutobalanceDisplayTime");
+
+	// m_bAllowWeaponSwitch
+	[SchemaMember("CCSGameRules", "m_bAllowWeaponSwitch")]
+	public ref bool AllowWeaponSwitch => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bAllowWeaponSwitch");
+
+	// m_bRoundTimeWarningTriggered
+	[SchemaMember("CCSGameRules", "m_bRoundTimeWarningTriggered")]
+	public ref bool RoundTimeWarningTriggered => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bRoundTimeWarningTriggered");
+
+	// m_phaseChangeAnnouncementTime
+	[SchemaMember("CCSGameRules", "m_phaseChangeAnnouncementTime")]
+	public ref float PhaseChangeAnnouncementTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_phaseChangeAnnouncementTime");
+
+	// m_fNextUpdateTeamClanNamesTime
+	[SchemaMember("CCSGameRules", "m_fNextUpdateTeamClanNamesTime")]
+	public ref float NextUpdateTeamClanNamesTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_fNextUpdateTeamClanNamesTime");
+
+	// m_flLastThinkTime
+	[SchemaMember("CCSGameRules", "m_flLastThinkTime")]
+	public ref float LastThinkTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flLastThinkTime");
+
+	// m_fAccumulatedRoundOffDamage
+	[SchemaMember("CCSGameRules", "m_fAccumulatedRoundOffDamage")]
+	public ref float AccumulatedRoundOffDamage => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_fAccumulatedRoundOffDamage");
+
+	// m_nShorthandedBonusLastEvalRound
+	[SchemaMember("CCSGameRules", "m_nShorthandedBonusLastEvalRound")]
+	public ref Int32 ShorthandedBonusLastEvalRound => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nShorthandedBonusLastEvalRound");
+
+	// m_nMatchAbortedEarlyReason
+	[SchemaMember("CCSGameRules", "m_nMatchAbortedEarlyReason")]
+	public ref Int32 MatchAbortedEarlyReason => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nMatchAbortedEarlyReason");
+
+	// m_bHasTriggeredRoundStartMusic
+	[SchemaMember("CCSGameRules", "m_bHasTriggeredRoundStartMusic")]
+	public ref bool HasTriggeredRoundStartMusic => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bHasTriggeredRoundStartMusic");
+
+	// m_bHasTriggeredCoopSpawnReset
+	[SchemaMember("CCSGameRules", "m_bHasTriggeredCoopSpawnReset")]
+	public ref bool HasTriggeredCoopSpawnReset => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bHasTriggeredCoopSpawnReset");
+
+	// m_bSwitchingTeamsAtRoundReset
+	[SchemaMember("CCSGameRules", "m_bSwitchingTeamsAtRoundReset")]
+	public ref bool SwitchingTeamsAtRoundReset => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bSwitchingTeamsAtRoundReset");
+
+	// m_pGameModeRules
+	[SchemaMember("CCSGameRules", "m_pGameModeRules")]
+	public CCSGameModeRules? GameModeRules => Schema.GetPointer<CCSGameModeRules>(this.Handle, "CCSGameRules", "m_pGameModeRules");
+
+	// m_hPlayerResource
+	[SchemaMember("CCSGameRules", "m_hPlayerResource")]
+	public CHandle<CBaseEntity> PlayerResource => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CCSGameRules", "m_hPlayerResource");
+
+	// m_RetakeRules
+	[SchemaMember("CCSGameRules", "m_RetakeRules")]
+	public CRetakeGameRules RetakeRules => Schema.GetDeclaredClass<CRetakeGameRules>(this.Handle, "CCSGameRules", "m_RetakeRules");
+
+	// m_GuardianBotSkillLevelMax
+	[SchemaMember("CCSGameRules", "m_GuardianBotSkillLevelMax")]
+	public ref Int32 GuardianBotSkillLevelMax => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_GuardianBotSkillLevelMax");
+
+	// m_GuardianBotSkillLevelMin
+	[SchemaMember("CCSGameRules", "m_GuardianBotSkillLevelMin")]
+	public ref Int32 GuardianBotSkillLevelMin => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_GuardianBotSkillLevelMin");
+
+	// m_arrTeamUniqueKillWeaponsMatch
+	[SchemaMember("CCSGameRules", "m_arrTeamUniqueKillWeaponsMatch")]
+	public Span<NetworkedVector<Int32>> TeamUniqueKillWeaponsMatch => Schema.GetFixedArray<NetworkedVector<Int32>>(this.Handle, "CCSGameRules", "m_arrTeamUniqueKillWeaponsMatch", 4);
+
+	// m_bTeamLastKillUsedUniqueWeaponMatch
+	[SchemaMember("CCSGameRules", "m_bTeamLastKillUsedUniqueWeaponMatch")]
+	public Span<bool> TeamLastKillUsedUniqueWeaponMatch => Schema.GetFixedArray<bool>(this.Handle, "CCSGameRules", "m_bTeamLastKillUsedUniqueWeaponMatch", 4);
+
+	// m_nMatchEndCount
+	[SchemaMember("CCSGameRules", "m_nMatchEndCount")]
+	public ref byte MatchEndCount => ref Schema.GetRef<byte>(this.Handle, "CCSGameRules", "m_nMatchEndCount");
+
+	// m_nTTeamIntroVariant
+	[SchemaMember("CCSGameRules", "m_nTTeamIntroVariant")]
+	public ref Int32 TTeamIntroVariant => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nTTeamIntroVariant");
+
+	// m_nCTTeamIntroVariant
+	[SchemaMember("CCSGameRules", "m_nCTTeamIntroVariant")]
+	public ref Int32 CTTeamIntroVariant => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nCTTeamIntroVariant");
+
+	// m_bTeamIntroPeriod
+	[SchemaMember("CCSGameRules", "m_bTeamIntroPeriod")]
+	public ref bool TeamIntroPeriod => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bTeamIntroPeriod");
+
+	// m_fTeamIntroPeriodEnd
+	[SchemaMember("CCSGameRules", "m_fTeamIntroPeriodEnd")]
+	public ref float TeamIntroPeriodEnd => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_fTeamIntroPeriodEnd");
+
+	// m_bPlayedTeamIntroVO
+	[SchemaMember("CCSGameRules", "m_bPlayedTeamIntroVO")]
+	public ref bool PlayedTeamIntroVO => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bPlayedTeamIntroVO");
+
+	// m_iRoundEndWinnerTeam
+	[SchemaMember("CCSGameRules", "m_iRoundEndWinnerTeam")]
+	public ref Int32 RoundEndWinnerTeam => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iRoundEndWinnerTeam");
+
+	// m_eRoundEndReason
+	[SchemaMember("CCSGameRules", "m_eRoundEndReason")]
+	public ref Int32 RoundEndReason => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_eRoundEndReason");
+
+	// m_bRoundEndShowTimerDefend
+	[SchemaMember("CCSGameRules", "m_bRoundEndShowTimerDefend")]
+	public ref bool RoundEndShowTimerDefend => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bRoundEndShowTimerDefend");
+
+	// m_iRoundEndTimerTime
+	[SchemaMember("CCSGameRules", "m_iRoundEndTimerTime")]
+	public ref Int32 RoundEndTimerTime => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iRoundEndTimerTime");
+
+	// m_sRoundEndFunFactToken
+	[SchemaMember("CCSGameRules", "m_sRoundEndFunFactToken")]
+	public string RoundEndFunFactToken
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CCSGameRules", "m_sRoundEndFunFactToken"); }
+		set { Schema.SetString(this.Handle, "CCSGameRules", "m_sRoundEndFunFactToken", value); }
+	}
+
+	// m_iRoundEndFunFactPlayerSlot
+	[SchemaMember("CCSGameRules", "m_iRoundEndFunFactPlayerSlot")]
+	public ref Int32 RoundEndFunFactPlayerSlot => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iRoundEndFunFactPlayerSlot");
+
+	// m_iRoundEndFunFactData1
+	[SchemaMember("CCSGameRules", "m_iRoundEndFunFactData1")]
+	public ref Int32 RoundEndFunFactData1 => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iRoundEndFunFactData1");
+
+	// m_iRoundEndFunFactData2
+	[SchemaMember("CCSGameRules", "m_iRoundEndFunFactData2")]
+	public ref Int32 RoundEndFunFactData2 => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iRoundEndFunFactData2");
+
+	// m_iRoundEndFunFactData3
+	[SchemaMember("CCSGameRules", "m_iRoundEndFunFactData3")]
+	public ref Int32 RoundEndFunFactData3 => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iRoundEndFunFactData3");
+
+	// m_sRoundEndMessage
+	[SchemaMember("CCSGameRules", "m_sRoundEndMessage")]
+	public string RoundEndMessage
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CCSGameRules", "m_sRoundEndMessage"); }
+		set { Schema.SetString(this.Handle, "CCSGameRules", "m_sRoundEndMessage", value); }
+	}
+
+	// m_iRoundEndPlayerCount
+	[SchemaMember("CCSGameRules", "m_iRoundEndPlayerCount")]
+	public ref Int32 RoundEndPlayerCount => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iRoundEndPlayerCount");
+
+	// m_bRoundEndNoMusic
+	[SchemaMember("CCSGameRules", "m_bRoundEndNoMusic")]
+	public ref bool RoundEndNoMusic => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bRoundEndNoMusic");
+
+	// m_iRoundEndLegacy
+	[SchemaMember("CCSGameRules", "m_iRoundEndLegacy")]
+	public ref Int32 RoundEndLegacy => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iRoundEndLegacy");
+
+	// m_nRoundEndCount
+	[SchemaMember("CCSGameRules", "m_nRoundEndCount")]
+	public ref byte RoundEndCount => ref Schema.GetRef<byte>(this.Handle, "CCSGameRules", "m_nRoundEndCount");
+
+	// m_iRoundStartRoundNumber
+	[SchemaMember("CCSGameRules", "m_iRoundStartRoundNumber")]
+	public ref Int32 RoundStartRoundNumber => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iRoundStartRoundNumber");
+
+	// m_nRoundStartCount
+	[SchemaMember("CCSGameRules", "m_nRoundStartCount")]
+	public ref byte RoundStartCount => ref Schema.GetRef<byte>(this.Handle, "CCSGameRules", "m_nRoundStartCount");
+
+	// m_nRoundStartTicks
+	[SchemaMember("CCSGameRules", "m_nRoundStartTicks")]
+	public NetworkedVector<Int32> RoundStartTicks => Schema.GetDeclaredClass<NetworkedVector<Int32>>(this.Handle, "CCSGameRules", "m_nRoundStartTicks");
+
+	// m_flLastPerfSampleTime
+	[SchemaMember("CCSGameRules", "m_flLastPerfSampleTime")]
+	public ref double LastPerfSampleTime => ref Schema.GetRef<double>(this.Handle, "CCSGameRules", "m_flLastPerfSampleTime");
+
+	// m_bSkipNextServerPerfSample
+	[SchemaMember("CCSGameRules", "m_bSkipNextServerPerfSample")]
+	public ref bool SkipNextServerPerfSample => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bSkipNextServerPerfSample");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGameRulesProxy.g.cs

@@ -0,0 +1,25 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSGameRulesProxy : CGameRulesProxy
+{
+    public CCSGameRulesProxy (IntPtr pointer) : base(pointer) {}
+
+	// m_pGameRules
+	[SchemaMember("CCSGameRulesProxy", "m_pGameRules")]
+	public CCSGameRules? GameRules => Schema.GetPointer<CCSGameRules>(this.Handle, "CCSGameRulesProxy", "m_pGameRules");
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSMinimapBoundary.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSMinimapBoundary : CBaseEntity
+{
+    public CCSMinimapBoundary (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSObserverPawn.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSObserverPawn : CCSPlayerPawnBase
+{
+    public CCSObserverPawn (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSObserver_CameraServices.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSObserver_CameraServices : CCSPlayerBase_CameraServices
+{
+    public CCSObserver_CameraServices (IntPtr pointer) : base(pointer) {}
+
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSObserver_MovementServices.g.cs

@@ -0,0 +1,21 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using CounterStrikeSharp;
+using CounterStrikeSharp.API.Modules.Events;
+using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CCSObserver_MovementServices : CPlayer_MovementServices
+{
+    public CCSObserver_MovementServices (IntPtr pointer) : base(pointer) {}
+
+}