stackit-observability 0.0.1a0__py3-none-any.whl

stackit/observability/models/update_grafana_configs_payload_generic_oauth.py

@@ -0,0 +1,135 @@
+# 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
+from typing_extensions import Self
+
+
+class UpdateGrafanaConfigsPayloadGenericOauth(BaseModel):
+    """
+    UpdateGrafanaConfigsPayloadGenericOauth
+    """
+
+    api_url: StrictStr = Field(
+        description="Set api_url to the resource that returns OpenID UserInfo compatible information.", alias="apiUrl"
+    )
+    auth_url: StrictStr = Field(description="Authentication endpoint of idp.", alias="authUrl")
+    enabled: StrictBool = Field(description="enable or disable generic oauth login")
+    name: Optional[StrictStr] = Field(default=None, description="Display name for the oAuth provider")
+    oauth_client_id: StrictStr = Field(description="Oauth client id for auth endpoint.", alias="oauthClientId")
+    oauth_client_secret: StrictStr = Field(
+        description="Oauth client secret for auth endpoint.", alias="oauthClientSecret"
+    )
+    role_attribute_path: StrictStr = Field(
+        description="Grafana checks for the presence of a role using the JMESPath specified via the role_attribute_path configuration option. The JMESPath is applied to the id_token first. If there is no match, then the UserInfo endpoint specified via the api_url configuration option is tried next. The result after evaluation of the role_attribute_path JMESPath expression should be a valid Grafana role, for example, Viewer, Editor or Admin For example: contains(roles[\\*], 'grafana-admin') && 'Admin' || contains(roles[\\*], 'grafana-editor') && 'Editor' || contains(roles[\\*], 'grafana-viewer') && 'Viewer'",
+        alias="roleAttributePath",
+    )
+    role_attribute_strict: Optional[StrictBool] = Field(
+        default=True,
+        description="If  therole_attribute_path property does not return a role, then the user is assigned the Viewer role by default. You can disable the role assignment by setting role_attribute_strict = true. It denies user access if no role or an invalid role is returned.",
+        alias="roleAttributeStrict",
+    )
+    scopes: Optional[StrictStr] = Field(
+        default="openid profile email", description="Space seperated list of scopes of the token"
+    )
+    token_url: StrictStr = Field(description="Token endpoint of the idp.", alias="tokenUrl")
+    use_pkce: Optional[StrictBool] = Field(
+        default=None, description="enable or disable Proof Key for Code Exchange", alias="usePkce"
+    )
+    __properties: ClassVar[List[str]] = [
+        "apiUrl",
+        "authUrl",
+        "enabled",
+        "name",
+        "oauthClientId",
+        "oauthClientSecret",
+        "roleAttributePath",
+        "roleAttributeStrict",
+        "scopes",
+        "tokenUrl",
+        "usePkce",
+    ]
+
+    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 UpdateGrafanaConfigsPayloadGenericOauth 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 UpdateGrafanaConfigsPayloadGenericOauth from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "apiUrl": obj.get("apiUrl"),
+                "authUrl": obj.get("authUrl"),
+                "enabled": obj.get("enabled"),
+                "name": obj.get("name"),
+                "oauthClientId": obj.get("oauthClientId"),
+                "oauthClientSecret": obj.get("oauthClientSecret"),
+                "roleAttributePath": obj.get("roleAttributePath"),
+                "roleAttributeStrict": (
+                    obj.get("roleAttributeStrict") if obj.get("roleAttributeStrict") is not None else True
+                ),
+                "scopes": obj.get("scopes") if obj.get("scopes") is not None else "openid profile email",
+                "tokenUrl": obj.get("tokenUrl"),
+                "usePkce": obj.get("usePkce"),
+            }
+        )
+        return _obj

stackit/observability/models/update_instance_payload.py

@@ -0,0 +1,88 @@
+# 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, StrictStr
+from typing_extensions import Annotated, Self
+
+
+class UpdateInstancePayload(BaseModel):
+    """
+    Create update instance body.
+    """
+
+    name: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=200)]] = Field(
+        default=None, description="Name of the service"
+    )
+    parameter: Optional[Dict[str, Any]] = Field(default=None, description="additional parameters")
+    plan_id: StrictStr = Field(description="uuid of the plan to create/update", alias="planId")
+    __properties: ClassVar[List[str]] = ["name", "parameter", "planId"]
+
+    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 UpdateInstancePayload 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 UpdateInstancePayload from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {"name": obj.get("name"), "parameter": obj.get("parameter"), "planId": obj.get("planId")}
+        )
+        return _obj

stackit/observability/models/update_metrics_storage_retention_payload.py

@@ -0,0 +1,99 @@
+# 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 UpdateMetricsStorageRetentionPayload(BaseModel):
+    """
+    UpdateMetricsStorageRetentionPayload
+    """
+
+    metrics_retention_time1h: Annotated[str, Field(min_length=2, strict=True, max_length=8)] = Field(
+        description="Retention time of longtime storage of 1h sampled data. After that time the data will be deleted permanently. `Additional Validators:` * Should be a valid time string * Should not be bigger than metricsRetentionTime5m",
+        alias="metricsRetentionTime1h",
+    )
+    metrics_retention_time5m: Annotated[str, Field(min_length=2, strict=True, max_length=8)] = Field(
+        description="Retention time of longtime storage of 5m sampled data. After that time the data will be down sampled to 1h. `Additional Validators:` * Should be a valid time string * Should not be bigger than metricsRetentionTimeRaw",
+        alias="metricsRetentionTime5m",
+    )
+    metrics_retention_time_raw: Annotated[str, Field(min_length=2, strict=True, max_length=8)] = Field(
+        description="Retention time of longtime storage of raw sampled data. After that time the data will be down sampled to 5m. Keep in mind, that the initial goal of downsampling is not saving disk or object storage space. In fact, downsampling doesn't save you any space but instead, it adds 2 more blocks for each raw block which are only slightly smaller or relatively similar size to raw block. This is done by internal downsampling implementation which to be mathematically correct holds various aggregations. This means that downsampling can increase the size of your storage a bit (~3x), if you choose to store all resolutions (recommended). The goal of downsampling is to provide an opportunity to get fast results for range queries of big time intervals like months or years. `Additional Validators:` * Should be a valid time string * Should not be bigger than 13 months",
+        alias="metricsRetentionTimeRaw",
+    )
+    __properties: ClassVar[List[str]] = ["metricsRetentionTime1h", "metricsRetentionTime5m", "metricsRetentionTimeRaw"]
+
+    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 UpdateMetricsStorageRetentionPayload 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 UpdateMetricsStorageRetentionPayload from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "metricsRetentionTime1h": obj.get("metricsRetentionTime1h"),
+                "metricsRetentionTime5m": obj.get("metricsRetentionTime5m"),
+                "metricsRetentionTimeRaw": obj.get("metricsRetentionTimeRaw"),
+            }
+        )
+        return _obj

stackit/observability/models/update_scrape_config_payload.py

@@ -0,0 +1,225 @@
+# 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, Union
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    StrictBool,
+    StrictFloat,
+    StrictInt,
+    StrictStr,
+    field_validator,
+)
+from typing_extensions import Annotated, Self
+
+from stackit.observability.models.create_scrape_config_payload_basic_auth import (
+    CreateScrapeConfigPayloadBasicAuth,
+)
+from stackit.observability.models.create_scrape_config_payload_http_sd_configs_inner_oauth2_tls_config import (
+    CreateScrapeConfigPayloadHttpSdConfigsInnerOauth2TlsConfig,
+)
+from stackit.observability.models.create_scrape_config_payload_metrics_relabel_configs_inner import (
+    CreateScrapeConfigPayloadMetricsRelabelConfigsInner,
+)
+from stackit.observability.models.update_scrape_config_payload_static_configs_inner import (
+    UpdateScrapeConfigPayloadStaticConfigsInner,
+)
+
+
+class UpdateScrapeConfigPayload(BaseModel):
+    """
+    UpdateScrapeConfigPayload
+    """
+
+    basic_auth: Optional[CreateScrapeConfigPayloadBasicAuth] = Field(default=None, alias="basicAuth")
+    bearer_token: Optional[StrictStr] = Field(
+        default=None,
+        description="Sets the 'Authorization' header on every scrape request with the configured bearer token. It is mutually exclusive with 'bearer_token_file'. `Additional Validators:` * needs to be a valid bearer token * if bearerToken is in the body no other authentication method should be in the body",
+        alias="bearerToken",
+    )
+    honor_labels: Optional[StrictBool] = Field(
+        default=False,
+        description="Note that any globally configured 'external_labels' are unaffected by this setting. In communication with external systems, they are always applied only when a time series does not have a given label yet and are ignored otherwise.",
+        alias="honorLabels",
+    )
+    honor_time_stamps: Optional[StrictBool] = Field(
+        default=False,
+        description="honor_timestamps controls whether Prometheus respects the timestamps present in scraped data. If honor_timestamps is set to 'true', the timestamps of the metrics exposed by the target will be used.",
+        alias="honorTimeStamps",
+    )
+    metrics_path: Annotated[str, Field(min_length=1, strict=True, max_length=200)] = Field(
+        description="The HTTP resource path on which to fetch metrics from targets. E.g. /metrics", alias="metricsPath"
+    )
+    metrics_relabel_configs: Optional[List[CreateScrapeConfigPayloadMetricsRelabelConfigsInner]] = Field(
+        default=None, description="List of metric relabel configurations", alias="metricsRelabelConfigs"
+    )
+    params: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="Optional http params `Additional Validators:` * should not contain more than 5 keys * each key and value should not have more than 200 characters",
+    )
+    sample_limit: Optional[Union[StrictFloat, StrictInt]] = Field(
+        default=None,
+        description="Per-scrape limit on number of scraped samples that will be accepted. If more than this number of samples are present after metric relabeling the entire scrape will be treated as failed. The total limit depends on the service plan target limits * samples",
+        alias="sampleLimit",
+    )
+    scheme: StrictStr = Field(description="Configures the protocol scheme used for requests. https or http")
+    scrape_interval: Annotated[str, Field(min_length=2, strict=True, max_length=8)] = Field(
+        description="How frequently to scrape targets from this job. E.g. 5m `Additional Validators:` * must be a valid time format* must be >= 60s",
+        alias="scrapeInterval",
+    )
+    scrape_timeout: Annotated[str, Field(min_length=2, strict=True, max_length=8)] = Field(
+        description="Per-scrape timeout when scraping this job. `Additional Validators:` * must be a valid time format* must be smaller than scrapeInterval",
+        alias="scrapeTimeout",
+    )
+    static_configs: List[UpdateScrapeConfigPayloadStaticConfigsInner] = Field(
+        description="A list of scrape configurations.", alias="staticConfigs"
+    )
+    tls_config: Optional[CreateScrapeConfigPayloadHttpSdConfigsInnerOauth2TlsConfig] = Field(
+        default=None, alias="tlsConfig"
+    )
+    __properties: ClassVar[List[str]] = [
+        "basicAuth",
+        "bearerToken",
+        "honorLabels",
+        "honorTimeStamps",
+        "metricsPath",
+        "metricsRelabelConfigs",
+        "params",
+        "sampleLimit",
+        "scheme",
+        "scrapeInterval",
+        "scrapeTimeout",
+        "staticConfigs",
+        "tlsConfig",
+    ]
+
+    @field_validator("scheme")
+    def scheme_validate_enum(cls, value):
+        """Validates the enum"""
+        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 UpdateScrapeConfigPayload 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 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 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 UpdateScrapeConfigPayload from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate(
+            {
+                "basicAuth": (
+                    CreateScrapeConfigPayloadBasicAuth.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,
+                "metricsPath": obj.get("metricsPath") if obj.get("metricsPath") is not None else "/metrics",
+                "metricsRelabelConfigs": (
+                    [
+                        CreateScrapeConfigPayloadMetricsRelabelConfigsInner.from_dict(_item)
+                        for _item in obj["metricsRelabelConfigs"]
+                    ]
+                    if obj.get("metricsRelabelConfigs") is not None
+                    else None
+                ),
+                "params": obj.get("params"),
+                "sampleLimit": obj.get("sampleLimit"),
+                "scheme": obj.get("scheme"),
+                "scrapeInterval": obj.get("scrapeInterval"),
+                "scrapeTimeout": obj.get("scrapeTimeout"),
+                "staticConfigs": (
+                    [UpdateScrapeConfigPayloadStaticConfigsInner.from_dict(_item) for _item in obj["staticConfigs"]]
+                    if obj.get("staticConfigs") is not None
+                    else None
+                ),
+                "tlsConfig": (
+                    CreateScrapeConfigPayloadHttpSdConfigsInnerOauth2TlsConfig.from_dict(obj["tlsConfig"])
+                    if obj.get("tlsConfig") is not None
+                    else None
+                ),
+            }
+        )
+        return _obj

stackit/observability/models/update_scrape_config_payload_static_configs_inner.py

@@ -0,0 +1,88 @@
+# 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 UpdateScrapeConfigPayloadStaticConfigsInner(BaseModel):
+    """
+    UpdateScrapeConfigPayloadStaticConfigsInner
+    """
+
+    labels: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="Labels assigned to all metrics scraped from the targets. `Additional Validators:` * should not contain more than 5 keys * each key and value should not be longer than 200 characters",
+    )
+    targets: List[Annotated[str, Field(min_length=1, strict=True, max_length=500)]] = Field(
+        description="The targets specified by the static config."
+    )
+    __properties: ClassVar[List[str]] = ["labels", "targets"]
+
+    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 UpdateScrapeConfigPayloadStaticConfigsInner 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 UpdateScrapeConfigPayloadStaticConfigsInner from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({"labels": obj.get("labels"), "targets": obj.get("targets")})
+        return _obj