stackit-observability 0.0.1a0__py3-none-any.whl

stackit/observability/models/instance.py

@@ -0,0 +1,155 @@
+# coding: utf-8
+
+"""
+    STACKIT Observability API
+
+    API endpoints for Observability on STACKIT
+
+    The version of the OpenAPI document: 1.1.1
+    Contact: stackit-argus@mail.schwarz
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501 docstring might be too long
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    StrictBool,
+    StrictStr,
+    field_validator,
+)
+from typing_extensions import Annotated, Self
+
+from stackit.observability.models.plan_model import PlanModel
+
+
+class Instance(BaseModel):
+    """
+    Instance
+    """
+
+    cluster: Annotated[str, Field(min_length=1, strict=True, max_length=63)]
+    grafana_public_read_access: StrictBool = Field(alias="grafanaPublicReadAccess")
+    grafana_use_stackit_sso: StrictBool = Field(alias="grafanaUseStackitSso")
+    instance: Annotated[str, Field(min_length=1, strict=True, max_length=63)]
+    metrics_retention_time1h: Annotated[int, Field(strict=True, ge=0)] = Field(alias="metricsRetentionTime1h")
+    metrics_retention_time5m: Annotated[int, Field(strict=True, ge=0)] = Field(alias="metricsRetentionTime5m")
+    metrics_retention_time_raw: Annotated[int, Field(strict=True, ge=0)] = Field(alias="metricsRetentionTimeRaw")
+    name: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=300)]] = None
+    plan: PlanModel
+    state: Optional[StrictStr] = None
+    __properties: ClassVar[List[str]] = [
+        "cluster",
+        "grafanaPublicReadAccess",
+        "grafanaUseStackitSso",
+        "instance",
+        "metricsRetentionTime1h",
+        "metricsRetentionTime5m",
+        "metricsRetentionTimeRaw",
+        "name",
+        "plan",
+        "state",
+    ]
+
+    @field_validator("state")
+    def state_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(
+            [
+                "Component creation started",
+                "Component creation failed",
+                "Component creation succeeded. Now need to check readiness",
+                "Component creation succeeded",
+                "Component deletion started",
+                "Component deletion failed",
+                "Component deletion succeeded",
+                "Component deletion of routine succeeded. Now need to check if resources gone",
+                "Component deletion buckets succeeded",
+                "Component update failed",
+                "Component update started",
+                "Component update creation succeeded",
+                "Component update downgrade deletion resources succeeded",
+            ]
+        ):
+            raise ValueError(
+                "must be one of enum values ('Component creation started', 'Component creation failed', 'Component creation succeeded. Now need to check readiness', 'Component creation succeeded', 'Component deletion started', 'Component deletion failed', 'Component deletion succeeded', 'Component deletion of routine succeeded. Now need to check if resources gone', 'Component deletion buckets succeeded', 'Component update failed', 'Component update started', 'Component update creation succeeded', 'Component update downgrade deletion resources succeeded')"
+            )
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of Instance from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of plan
+        if self.plan:
+            _dict["plan"] = self.plan.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Instance from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "cluster": obj.get("cluster"),
+                "grafanaPublicReadAccess": obj.get("grafanaPublicReadAccess"),
+                "grafanaUseStackitSso": obj.get("grafanaUseStackitSso"),
+                "instance": obj.get("instance"),
+                "metricsRetentionTime1h": obj.get("metricsRetentionTime1h"),
+                "metricsRetentionTime5m": obj.get("metricsRetentionTime5m"),
+                "metricsRetentionTimeRaw": obj.get("metricsRetentionTimeRaw"),
+                "name": obj.get("name"),
+                "plan": PlanModel.from_dict(obj["plan"]) if obj.get("plan") is not None else None,
+                "state": obj.get("state"),
+            }
+        )
+        return _obj

stackit/observability/models/instance_response.py

@@ -0,0 +1,82 @@
+# coding: utf-8
+
+"""
+    STACKIT Observability API
+
+    API endpoints for Observability on STACKIT
+
+    The version of the OpenAPI document: 1.1.1
+    Contact: stackit-argus@mail.schwarz
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501 docstring might be too long
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Annotated, Self
+
+
+class InstanceResponse(BaseModel):
+    """
+    InstanceResponse
+    """
+
+    message: Annotated[str, Field(min_length=1, strict=True)]
+    __properties: ClassVar[List[str]] = ["message"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of InstanceResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InstanceResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"message": obj.get("message")})
+        return _obj

stackit/observability/models/instance_sensitive_data.py

@@ -0,0 +1,159 @@
+# coding: utf-8
+
+"""
+    STACKIT Observability API
+
+    API endpoints for Observability on STACKIT
+
+    The version of the OpenAPI document: 1.1.1
+    Contact: stackit-argus@mail.schwarz
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501 docstring might be too long
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
+from typing_extensions import Annotated, Self
+
+from stackit.observability.models.plan_model import PlanModel
+
+
+class InstanceSensitiveData(BaseModel):
+    """
+    InstanceSensitiveData
+    """
+
+    alerting_url: Annotated[str, Field(min_length=1, strict=True)] = Field(alias="alertingUrl")
+    cluster: Annotated[str, Field(min_length=1, strict=True, max_length=63)]
+    dashboard_url: Annotated[str, Field(min_length=1, strict=True)] = Field(alias="dashboardUrl")
+    grafana_admin_password: Annotated[str, Field(min_length=32, strict=True)] = Field(alias="grafanaAdminPassword")
+    grafana_admin_user: Annotated[str, Field(min_length=1, strict=True)] = Field(alias="grafanaAdminUser")
+    grafana_public_read_access: StrictBool = Field(alias="grafanaPublicReadAccess")
+    grafana_url: Annotated[str, Field(min_length=1, strict=True)] = Field(alias="grafanaUrl")
+    grafana_use_stackit_sso: StrictBool = Field(alias="grafanaUseStackitSso")
+    instance: Annotated[str, Field(min_length=1, strict=True, max_length=63)]
+    jaeger_traces_url: Annotated[str, Field(min_length=1, strict=True)] = Field(alias="jaegerTracesUrl")
+    jaeger_ui_url: Annotated[str, Field(min_length=1, strict=True)] = Field(alias="jaegerUiUrl")
+    logs_push_url: Annotated[str, Field(min_length=1, strict=True)] = Field(alias="logsPushUrl")
+    logs_url: Annotated[str, Field(min_length=1, strict=True)] = Field(alias="logsUrl")
+    metrics_retention_time1h: Annotated[int, Field(strict=True, ge=0)] = Field(alias="metricsRetentionTime1h")
+    metrics_retention_time5m: Annotated[int, Field(strict=True, ge=0)] = Field(alias="metricsRetentionTime5m")
+    metrics_retention_time_raw: Annotated[int, Field(strict=True, ge=0)] = Field(alias="metricsRetentionTimeRaw")
+    metrics_url: Annotated[str, Field(min_length=1, strict=True)] = Field(alias="metricsUrl")
+    name: Optional[Annotated[str, Field(strict=True, max_length=300)]] = ""
+    otlp_traces_url: Annotated[str, Field(min_length=1, strict=True)] = Field(alias="otlpTracesUrl")
+    plan: PlanModel
+    push_metrics_url: Annotated[str, Field(min_length=1, strict=True)] = Field(alias="pushMetricsUrl")
+    targets_url: Annotated[str, Field(min_length=1, strict=True)] = Field(alias="targetsUrl")
+    zipkin_spans_url: Annotated[str, Field(min_length=1, strict=True)] = Field(alias="zipkinSpansUrl")
+    __properties: ClassVar[List[str]] = [
+        "alertingUrl",
+        "cluster",
+        "dashboardUrl",
+        "grafanaAdminPassword",
+        "grafanaAdminUser",
+        "grafanaPublicReadAccess",
+        "grafanaUrl",
+        "grafanaUseStackitSso",
+        "instance",
+        "jaegerTracesUrl",
+        "jaegerUiUrl",
+        "logsPushUrl",
+        "logsUrl",
+        "metricsRetentionTime1h",
+        "metricsRetentionTime5m",
+        "metricsRetentionTimeRaw",
+        "metricsUrl",
+        "name",
+        "otlpTracesUrl",
+        "plan",
+        "pushMetricsUrl",
+        "targetsUrl",
+        "zipkinSpansUrl",
+    ]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of InstanceSensitiveData from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of plan
+        if self.plan:
+            _dict["plan"] = self.plan.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of InstanceSensitiveData from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "alertingUrl": obj.get("alertingUrl"),
+                "cluster": obj.get("cluster"),
+                "dashboardUrl": obj.get("dashboardUrl"),
+                "grafanaAdminPassword": obj.get("grafanaAdminPassword"),
+                "grafanaAdminUser": obj.get("grafanaAdminUser"),
+                "grafanaPublicReadAccess": obj.get("grafanaPublicReadAccess"),
+                "grafanaUrl": obj.get("grafanaUrl"),
+                "grafanaUseStackitSso": obj.get("grafanaUseStackitSso"),
+                "instance": obj.get("instance"),
+                "jaegerTracesUrl": obj.get("jaegerTracesUrl"),
+                "jaegerUiUrl": obj.get("jaegerUiUrl"),
+                "logsPushUrl": obj.get("logsPushUrl"),
+                "logsUrl": obj.get("logsUrl"),
+                "metricsRetentionTime1h": obj.get("metricsRetentionTime1h"),
+                "metricsRetentionTime5m": obj.get("metricsRetentionTime5m"),
+                "metricsRetentionTimeRaw": obj.get("metricsRetentionTimeRaw"),
+                "metricsUrl": obj.get("metricsUrl"),
+                "name": obj.get("name") if obj.get("name") is not None else "",
+                "otlpTracesUrl": obj.get("otlpTracesUrl"),
+                "plan": PlanModel.from_dict(obj["plan"]) if obj.get("plan") is not None else None,
+                "pushMetricsUrl": obj.get("pushMetricsUrl"),
+                "targetsUrl": obj.get("targetsUrl"),
+                "zipkinSpansUrl": obj.get("zipkinSpansUrl"),
+            }
+        )
+        return _obj

stackit/observability/models/job.py

@@ -0,0 +1,207 @@
+# coding: utf-8
+
+"""
+    STACKIT Observability API
+
+    API endpoints for Observability on STACKIT
+
+    The version of the OpenAPI document: 1.1.1
+    Contact: stackit-argus@mail.schwarz
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501 docstring might be too long
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    StrictBool,
+    StrictStr,
+    field_validator,
+)
+from typing_extensions import Annotated, Self
+
+from stackit.observability.models.basic_auth import BasicAuth
+from stackit.observability.models.http_service_sd import HTTPServiceSD
+from stackit.observability.models.metrics_relabel_config import MetricsRelabelConfig
+from stackit.observability.models.o_auth2 import OAuth2
+from stackit.observability.models.static_configs import StaticConfigs
+from stackit.observability.models.tls_config import TLSConfig
+
+
+class Job(BaseModel):
+    """
+    Job
+    """
+
+    basic_auth: Optional[BasicAuth] = Field(default=None, alias="basicAuth")
+    bearer_token: Optional[Annotated[str, Field(min_length=1, strict=True)]] = Field(default=None, alias="bearerToken")
+    honor_labels: Optional[StrictBool] = Field(default=False, alias="honorLabels")
+    honor_time_stamps: Optional[StrictBool] = Field(default=False, alias="honorTimeStamps")
+    http_sd_configs: Optional[List[HTTPServiceSD]] = Field(default=None, alias="httpSdConfigs")
+    job_name: Annotated[str, Field(min_length=1, strict=True, max_length=200)] = Field(alias="jobName")
+    metrics_path: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=200)]] = Field(
+        default="/metrics", alias="metricsPath"
+    )
+    metrics_relabel_configs: Optional[List[MetricsRelabelConfig]] = Field(default=None, alias="metricsRelabelConfigs")
+    oauth2: Optional[OAuth2] = None
+    params: Optional[
+        Dict[
+            str, Annotated[List[Annotated[str, Field(min_length=1, strict=True, max_length=200)]], Field(max_length=5)]
+        ]
+    ] = None
+    sample_limit: Optional[Annotated[int, Field(le=1000000000, strict=True, ge=1)]] = Field(
+        default=None, alias="sampleLimit"
+    )
+    scheme: Optional[StrictStr] = "http"
+    scrape_interval: Annotated[str, Field(min_length=2, strict=True, max_length=8)] = Field(alias="scrapeInterval")
+    scrape_timeout: Annotated[str, Field(min_length=2, strict=True, max_length=8)] = Field(alias="scrapeTimeout")
+    static_configs: List[StaticConfigs] = Field(alias="staticConfigs")
+    tls_config: Optional[TLSConfig] = Field(default=None, alias="tlsConfig")
+    __properties: ClassVar[List[str]] = [
+        "basicAuth",
+        "bearerToken",
+        "honorLabels",
+        "honorTimeStamps",
+        "httpSdConfigs",
+        "jobName",
+        "metricsPath",
+        "metricsRelabelConfigs",
+        "oauth2",
+        "params",
+        "sampleLimit",
+        "scheme",
+        "scrapeInterval",
+        "scrapeTimeout",
+        "staticConfigs",
+        "tlsConfig",
+    ]
+
+    @field_validator("scheme")
+    def scheme_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(["http", "https"]):
+            raise ValueError("must be one of enum values ('http', 'https')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of Job from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of basic_auth
+        if self.basic_auth:
+            _dict["basicAuth"] = self.basic_auth.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in http_sd_configs (list)
+        _items = []
+        if self.http_sd_configs:
+            for _item in self.http_sd_configs:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["httpSdConfigs"] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in metrics_relabel_configs (list)
+        _items = []
+        if self.metrics_relabel_configs:
+            for _item in self.metrics_relabel_configs:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["metricsRelabelConfigs"] = _items
+        # override the default output from pydantic by calling `to_dict()` of oauth2
+        if self.oauth2:
+            _dict["oauth2"] = self.oauth2.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in static_configs (list)
+        _items = []
+        if self.static_configs:
+            for _item in self.static_configs:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict["staticConfigs"] = _items
+        # override the default output from pydantic by calling `to_dict()` of tls_config
+        if self.tls_config:
+            _dict["tlsConfig"] = self.tls_config.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Job from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "basicAuth": BasicAuth.from_dict(obj["basicAuth"]) if obj.get("basicAuth") is not None else None,
+                "bearerToken": obj.get("bearerToken"),
+                "honorLabels": obj.get("honorLabels") if obj.get("honorLabels") is not None else False,
+                "honorTimeStamps": obj.get("honorTimeStamps") if obj.get("honorTimeStamps") is not None else False,
+                "httpSdConfigs": (
+                    [HTTPServiceSD.from_dict(_item) for _item in obj["httpSdConfigs"]]
+                    if obj.get("httpSdConfigs") is not None
+                    else None
+                ),
+                "jobName": obj.get("jobName"),
+                "metricsPath": obj.get("metricsPath") if obj.get("metricsPath") is not None else "/metrics",
+                "metricsRelabelConfigs": (
+                    [MetricsRelabelConfig.from_dict(_item) for _item in obj["metricsRelabelConfigs"]]
+                    if obj.get("metricsRelabelConfigs") is not None
+                    else None
+                ),
+                "oauth2": OAuth2.from_dict(obj["oauth2"]) if obj.get("oauth2") is not None else None,
+                "params": obj.get("params"),
+                "sampleLimit": obj.get("sampleLimit"),
+                "scheme": obj.get("scheme") if obj.get("scheme") is not None else "http",
+                "scrapeInterval": obj.get("scrapeInterval"),
+                "scrapeTimeout": obj.get("scrapeTimeout"),
+                "staticConfigs": (
+                    [StaticConfigs.from_dict(_item) for _item in obj["staticConfigs"]]
+                    if obj.get("staticConfigs") is not None
+                    else None
+                ),
+                "tlsConfig": TLSConfig.from_dict(obj["tlsConfig"]) if obj.get("tlsConfig") is not None else None,
+            }
+        )
+        return _obj

stackit/observability/models/list_acl_response.py

@@ -0,0 +1,83 @@
+# coding: utf-8
+
+"""
+    STACKIT Observability API
+
+    API endpoints for Observability on STACKIT
+
+    The version of the OpenAPI document: 1.1.1
+    Contact: stackit-argus@mail.schwarz
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501 docstring might be too long
+
+from __future__ import annotations
+
+import json
+import pprint
+from typing import Any, ClassVar, Dict, List, Optional, Set
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Annotated, Self
+
+
+class ListACLResponse(BaseModel):
+    """
+    ListACLResponse
+    """
+
+    acl: List[Annotated[str, Field(min_length=1, strict=True, max_length=100)]]
+    message: Annotated[str, Field(min_length=1, strict=True)]
+    __properties: ClassVar[List[str]] = ["acl", "message"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of ListACLResponse from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of ListACLResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"acl": obj.get("acl"), "message": obj.get("message")})
+        return _obj