more work.

Author: dcarbone

src/ConfigEntry/MeshConfigEntry.php

@@ -28,7 +28,7 @@ class MeshConfigEntry extends AbstractModel implements ConfigEntry
     use ConfigEntryTrait;
 
     public string $Partition;
-    public TransparentProxyConfig $TransparentProxy;
+    public TransparentProxyMeshConfig $TransparentProxy;
     public bool $AllowEnablingPermissiveMutualTLS;
     public null|MeshTLSConfig $TLS;
     public null|MeshHTTPConfig $HTTP;
@@ -38,7 +38,7 @@ public function __construct(
         null|array $data = null, // Deprecated, will be removed.
         string $Partition = '',
         string $Namespace = '',
-        null|TransparentProxyConfig $TransparentProxy = null,
+        null|TransparentProxyMeshConfig $TransparentProxy = null,
         bool $AllowEnablingPermissiveMutualTLS = false,
         null|MeshTLSConfig $TLS = null,
         null|MeshHTTPConfig $HTTP = null,
@@ -73,14 +73,110 @@ public function getName(): string
         return Consul::MeshConfigMesh;
     }
 
-    public function getTransparentProxy(): TransparentProxyConfig
+    public function getTransparentProxy(): TransparentProxyMeshConfig
     {
         return $this->TransparentProxy;
     }
 
-    public function setTransparentProxy(TransparentProxyConfig $TransparentProxy): self
+    public function setTransparentProxy(TransparentProxyMeshConfig $TransparentProxy): self
     {
         $this->TransparentProxy = $TransparentProxy;
         return $this;
     }
+
+    public function isAllowEnablingPermissiveMutualTLS(): bool
+    {
+        return $this->AllowEnablingPermissiveMutualTLS;
+    }
+
+    public function setAllowEnablingPermissiveMutualTLS(bool $AllowEnablingPermissiveMutualTLS): self
+    {
+        $this->AllowEnablingPermissiveMutualTLS = $AllowEnablingPermissiveMutualTLS;
+        return $this;
+    }
+
+    public function getTLS(): null|MeshTLSConfig
+    {
+        return $this->TLS;
+    }
+
+    public function setTLS(null|MeshTLSConfig $TLS): self
+    {
+        $this->TLS = $TLS;
+        return $this;
+    }
+
+    public function getHTTP(): null|MeshHTTPConfig
+    {
+        return $this->HTTP;
+    }
+
+    public function setHTTP(null|MeshHTTPConfig $HTTP): self
+    {
+        $this->HTTP = $HTTP;
+        return $this;
+    }
+
+    public function getPeering(): null|PeeringMeshConfig
+    {
+        return $this->Peering;
+    }
+
+    public function setPeering(null|PeeringMeshConfig $Peering): self
+    {
+        $this->Peering = $Peering;
+        return $this;
+    }
+
+    public static function jsonUnserialize(\stdClass $decoded, null|self $n = null): self
+    {
+        $n = $n ?? new self();
+        foreach ($decoded as $k => $v) {
+            if ('TransparentProxy' === $k || 'transparent_proxy' === $k) {
+                $n->TransparentProxy = null === $v ? new TransparentProxyMeshConfig() : TransparentProxyMeshConfig::jsonUnserialize($v);
+            } elseif ('TLS' === $k) {
+                $n->TLS = null === $v ? null : MeshTLSConfig::jsonUnserialize($v);
+            } elseif ('HTTP' === $k) {
+                $n->HTTP = null === $v ? null : MeshHTTPConfig::jsonUnserialize($v);
+            } elseif ('Peering' === $k) {
+                $n->Peering = null === $v ? null : PeeringMeshConfig::jsonUnserialize($v);
+            } elseif ('allow_enabling_permissive_mutual_tls' === $k) {
+                $n->AllowEnablingPermissiveMutualTLS = $v;
+            } else {
+                $n->{$k} = $v;
+            }
+        }
+        return $n;
+    }
+
+    public function jsonSerialize(): \stdClass
+    {
+        $out = new \stdClass();
+        foreach ($this->_getDynamicFields() as $k => $v) {
+            $out->{$k} = $v;
+        }
+        $out->Kind = Consul::MeshConfigMesh;
+        if ('' !== $this->Partition) {
+            $out->Partition = $this->Partition;
+        }
+        $out->TransparentProxy = $this->TransparentProxy;
+        if ($this->AllowEnablingPermissiveMutualTLS) {
+            $out->allow_enabling_permissive_mutual_tls = true;
+        }
+        if (null !== $this->TLS) {
+            $out->TLS = $this->TLS;
+        }
+        if (null !== $this->HTTP) {
+            $out->HTTP = $this->HTTP;
+        }
+        if (null !== $this->Peering) {
+            $out->Peering = $this->Peering;
+        }
+        if (null !== $this->Meta) {
+            $out->Meta = $this->Meta;
+        }
+        $out->CreateIndex = $this->CreateIndex;
+        $out->ModifyIndex = $this->ModifyIndex;
+        return $out;
+    }
 }

src/ConfigEntry/TransparentProxyMeshConfig.php

@@ -0,0 +1,64 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DCarbone\PHPConsulAPI\ConfigEntry;
+
+/*
+   Copyright 2016-2025 Daniel Carbone (daniel.p.carbone@gmail.com)
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+ */
+
+use DCarbone\PHPConsulAPI\AbstractModel;
+
+class TransparentProxyMeshConfig extends AbstractModel
+{
+    public bool $MeshDestinationsOnly;
+
+    public function __construct(bool $MeshDestinationsOnly = false)
+    {
+        $this->MeshDestinationsOnly = $MeshDestinationsOnly;
+    }
+
+    public function isMeshDestinationsOnly(): bool
+    {
+        return $this->MeshDestinationsOnly;
+    }
+
+    public function setMeshDestinationsOnly(bool $MeshDestinationsOnly): self
+    {
+        $this->MeshDestinationsOnly = $MeshDestinationsOnly;
+        return $this;
+    }
+
+    public static function jsonUnserialize(\stdClass $decoded): self
+    {
+        $n = new self();
+        foreach ($decoded as $k => $v) {
+            if ('mesh_destinations_only' === $k) {
+                $n->MeshDestinationsOnly = $v;
+            } else {
+                $n->{$k} = $v;
+            }
+        }
+        return $n;
+    }
+
+    public function jsonSerialize(): \stdClass
+    {
+        $o = new \stdClass();
+        $o->MeshDestinationsOnly = $this->MeshDestinationsOnly;
+        return $o;
+    }
+}