feat: fix(moq): render MoQ via explicit custom casing (RT-603)

* fix(moq): render MoQ via explicit custom casing (RT-603)

The moq token was 'initialism: true', which renders MOQ. MoQ (Media over
QUIC) is a mixed-case acronym, so use an explicit casing block (like DDoS):
pascal/capital = MoQ, camel/snake = moq. Fixes the API docs/SDK rendering 'Moq'.

(cherry picked from commit bbc15361ceba0c208977f40ba6e689e1611fc39d)

Author: stainless-app[bot]

.stats.yml

@@ -1,4 +1,4 @@
 configured_endpoints: 2409
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/cloudflare/cloudflare-64c75bcb4da367adfd4f8ef4a3f56ba72319441f8192961275c5908530d96b6a.yml
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/cloudflare/cloudflare-dfb646d2d43385c312e319a5f5c0d09c4f8b41d89e4486cd58acc970bfe74223.yml
 openapi_spec_hash: 5f2a1a80ef585c73c6b546c4075d18f8
-config_hash: bbf6df558b7c0807286a2085dd306dde
+config_hash: 517f3639f0355eae78476ce617456698

api.md

@@ -211,7 +211,7 @@ from cloudflare.types import (
 
 # [Calls](src/cloudflare/resources/calls/api.md)
 
-# [Moq](src/cloudflare/resources/moq/api.md)
+# [MoQ](src/cloudflare/resources/moq/api.md)
 
 # [CloudforceOne](src/cloudflare/resources/cloudforce_one/api.md)
 

src/cloudflare/_client.py

@@ -164,7 +164,7 @@
     from .resources.dns.dns import DNSResource, AsyncDNSResource
     from .resources.iam.iam import IAMResource, AsyncIAMResource
     from .resources.ips.ips import IPsResource, AsyncIPsResource
-    from .resources.moq.moq import MoqResource, AsyncMoqResource
+    from .resources.moq.moq import MoQResource, AsyncMoQResource
     from .resources.rum.rum import RUMResource, AsyncRUMResource
     from .resources.ssl.ssl import SSLResource, AsyncSSLResource
     from .resources.argo.argo import ArgoResource, AsyncArgoResource
@@ -968,10 +968,10 @@ def calls(self) -> CallsResource:
         return CallsResource(self)
 
     @cached_property
-    def moq(self) -> MoqResource:
-        from .resources.moq import MoqResource
+    def moq(self) -> MoQResource:
+        from .resources.moq import MoQResource
 
-        return MoqResource(self)
+        return MoQResource(self)
 
     @cached_property
     def cloudforce_one(self) -> CloudforceOneResource:
@@ -1926,10 +1926,10 @@ def calls(self) -> AsyncCallsResource:
         return AsyncCallsResource(self)
 
     @cached_property
-    def moq(self) -> AsyncMoqResource:
-        from .resources.moq import AsyncMoqResource
+    def moq(self) -> AsyncMoQResource:
+        from .resources.moq import AsyncMoQResource
 
-        return AsyncMoqResource(self)
+        return AsyncMoQResource(self)
 
     @cached_property
     def cloudforce_one(self) -> AsyncCloudforceOneResource:
@@ -2808,10 +2808,10 @@ def calls(self) -> calls.CallsResourceWithRawResponse:
         return CallsResourceWithRawResponse(self._client.calls)
 
     @cached_property
-    def moq(self) -> moq.MoqResourceWithRawResponse:
-        from .resources.moq import MoqResourceWithRawResponse
+    def moq(self) -> moq.MoQResourceWithRawResponse:
+        from .resources.moq import MoQResourceWithRawResponse
 
-        return MoqResourceWithRawResponse(self._client.moq)
+        return MoQResourceWithRawResponse(self._client.moq)
 
     @cached_property
     def cloudforce_one(self) -> cloudforce_one.CloudforceOneResourceWithRawResponse:
@@ -3517,10 +3517,10 @@ def calls(self) -> calls.AsyncCallsResourceWithRawResponse:
         return AsyncCallsResourceWithRawResponse(self._client.calls)
 
     @cached_property
-    def moq(self) -> moq.AsyncMoqResourceWithRawResponse:
-        from .resources.moq import AsyncMoqResourceWithRawResponse
+    def moq(self) -> moq.AsyncMoQResourceWithRawResponse:
+        from .resources.moq import AsyncMoQResourceWithRawResponse
 
-        return AsyncMoqResourceWithRawResponse(self._client.moq)
+        return AsyncMoQResourceWithRawResponse(self._client.moq)
 
     @cached_property
     def cloudforce_one(self) -> cloudforce_one.AsyncCloudforceOneResourceWithRawResponse:
@@ -4226,10 +4226,10 @@ def calls(self) -> calls.CallsResourceWithStreamingResponse:
         return CallsResourceWithStreamingResponse(self._client.calls)
 
     @cached_property
-    def moq(self) -> moq.MoqResourceWithStreamingResponse:
-        from .resources.moq import MoqResourceWithStreamingResponse
+    def moq(self) -> moq.MoQResourceWithStreamingResponse:
+        from .resources.moq import MoQResourceWithStreamingResponse
 
-        return MoqResourceWithStreamingResponse(self._client.moq)
+        return MoQResourceWithStreamingResponse(self._client.moq)
 
     @cached_property
     def cloudforce_one(self) -> cloudforce_one.CloudforceOneResourceWithStreamingResponse:
@@ -4943,10 +4943,10 @@ def calls(self) -> calls.AsyncCallsResourceWithStreamingResponse:
         return AsyncCallsResourceWithStreamingResponse(self._client.calls)
 
     @cached_property
-    def moq(self) -> moq.AsyncMoqResourceWithStreamingResponse:
-        from .resources.moq import AsyncMoqResourceWithStreamingResponse
+    def moq(self) -> moq.AsyncMoQResourceWithStreamingResponse:
+        from .resources.moq import AsyncMoQResourceWithStreamingResponse
 
-        return AsyncMoqResourceWithStreamingResponse(self._client.moq)
+        return AsyncMoQResourceWithStreamingResponse(self._client.moq)
 
     @cached_property
     def cloudforce_one(self) -> cloudforce_one.AsyncCloudforceOneResourceWithStreamingResponse:

src/cloudflare/resources/moq/__init__.py

@@ -1,12 +1,12 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 from .moq import (
-    MoqResource,
-    AsyncMoqResource,
-    MoqResourceWithRawResponse,
-    AsyncMoqResourceWithRawResponse,
-    MoqResourceWithStreamingResponse,
-    AsyncMoqResourceWithStreamingResponse,
+    MoQResource,
+    AsyncMoQResource,
+    MoQResourceWithRawResponse,
+    AsyncMoQResourceWithRawResponse,
+    MoQResourceWithStreamingResponse,
+    AsyncMoQResourceWithStreamingResponse,
 )
 from .relays import (
     RelaysResource,
@@ -24,10 +24,10 @@
     "AsyncRelaysResourceWithRawResponse",
     "RelaysResourceWithStreamingResponse",
     "AsyncRelaysResourceWithStreamingResponse",
-    "MoqResource",
-    "AsyncMoqResource",
-    "MoqResourceWithRawResponse",
-    "AsyncMoqResourceWithRawResponse",
-    "MoqResourceWithStreamingResponse",
-    "AsyncMoqResourceWithStreamingResponse",
+    "MoQResource",
+    "AsyncMoQResource",
+    "MoQResourceWithRawResponse",
+    "AsyncMoQResourceWithRawResponse",
+    "MoQResourceWithStreamingResponse",
+    "AsyncMoQResourceWithStreamingResponse",
 ]

src/cloudflare/resources/moq/api.md

@@ -1,4 +1,4 @@
-# Moq
+# MoQ
 
 ## Relays
 

src/cloudflare/resources/moq/moq.py

@@ -13,88 +13,88 @@
     AsyncRelaysResourceWithStreamingResponse,
 )
 
-__all__ = ["MoqResource", "AsyncMoqResource"]
+__all__ = ["MoQResource", "AsyncMoQResource"]
 
 
-class MoqResource(SyncAPIResource):
+class MoQResource(SyncAPIResource):
     @cached_property
     def relays(self) -> RelaysResource:
         return RelaysResource(self._client)
 
     @cached_property
-    def with_raw_response(self) -> MoqResourceWithRawResponse:
+    def with_raw_response(self) -> MoQResourceWithRawResponse:
         """
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
         For more information, see https://www.github.com/cloudflare/cloudflare-python#accessing-raw-response-data-eg-headers
         """
-        return MoqResourceWithRawResponse(self)
+        return MoQResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> MoqResourceWithStreamingResponse:
+    def with_streaming_response(self) -> MoQResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/cloudflare/cloudflare-python#with_streaming_response
         """
-        return MoqResourceWithStreamingResponse(self)
+        return MoQResourceWithStreamingResponse(self)
 
 
-class AsyncMoqResource(AsyncAPIResource):
+class AsyncMoQResource(AsyncAPIResource):
     @cached_property
     def relays(self) -> AsyncRelaysResource:
         return AsyncRelaysResource(self._client)
 
     @cached_property
-    def with_raw_response(self) -> AsyncMoqResourceWithRawResponse:
+    def with_raw_response(self) -> AsyncMoQResourceWithRawResponse:
         """
         This property can be used as a prefix for any HTTP method call to return
         the raw response object instead of the parsed content.
 
         For more information, see https://www.github.com/cloudflare/cloudflare-python#accessing-raw-response-data-eg-headers
         """
-        return AsyncMoqResourceWithRawResponse(self)
+        return AsyncMoQResourceWithRawResponse(self)
 
     @cached_property
-    def with_streaming_response(self) -> AsyncMoqResourceWithStreamingResponse:
+    def with_streaming_response(self) -> AsyncMoQResourceWithStreamingResponse:
         """
         An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
         For more information, see https://www.github.com/cloudflare/cloudflare-python#with_streaming_response
         """
-        return AsyncMoqResourceWithStreamingResponse(self)
+        return AsyncMoQResourceWithStreamingResponse(self)
 
 
-class MoqResourceWithRawResponse:
-    def __init__(self, moq: MoqResource) -> None:
+class MoQResourceWithRawResponse:
+    def __init__(self, moq: MoQResource) -> None:
         self._moq = moq
 
     @cached_property
     def relays(self) -> RelaysResourceWithRawResponse:
         return RelaysResourceWithRawResponse(self._moq.relays)
 
 
-class AsyncMoqResourceWithRawResponse:
-    def __init__(self, moq: AsyncMoqResource) -> None:
+class AsyncMoQResourceWithRawResponse:
+    def __init__(self, moq: AsyncMoQResource) -> None:
         self._moq = moq
 
     @cached_property
     def relays(self) -> AsyncRelaysResourceWithRawResponse:
         return AsyncRelaysResourceWithRawResponse(self._moq.relays)
 
 
-class MoqResourceWithStreamingResponse:
-    def __init__(self, moq: MoqResource) -> None:
+class MoQResourceWithStreamingResponse:
+    def __init__(self, moq: MoQResource) -> None:
         self._moq = moq
 
     @cached_property
     def relays(self) -> RelaysResourceWithStreamingResponse:
         return RelaysResourceWithStreamingResponse(self._moq.relays)
 
 
-class AsyncMoqResourceWithStreamingResponse:
-    def __init__(self, moq: AsyncMoqResource) -> None:
+class AsyncMoQResourceWithStreamingResponse:
+    def __init__(self, moq: AsyncMoQResource) -> None:
         self._moq = moq
 
     @cached_property