capo-codeguru-security 0.1.0__py3-none-any.whl

capo_codeguru_security/types/create_upload_url_request.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#CreateUploadUrlRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codeguru_security.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.scan_name
+
+
+class CreateUploadUrlRequest(TypedDict, closed=True):
+    scan_name: "capo_codeguru_security.types.scan_name.ScanName"
+    """<p>The name of the scan that will use the uploaded resource. CodeGuru Security uses the unique scan name to track revisions across multiple scans of the same resource. Use this <code>scanName</code> when you call <code>CreateScan</code> on the code resource you upload to this URL.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CreateUploadUrlRequest) -> dict:
+    out: dict = {}
+    out["scanName"] = value["scan_name"]
+    return out
+
+
+def deserialize_json(data: dict) -> CreateUploadUrlRequest:
+    out: CreateUploadUrlRequest = {}  # type: ignore[typeddict-item]
+    if data.get("scanName") is not None:
+        out["scan_name"] = data["scanName"]
+    else:
+        raise DeserializationError("CreateUploadUrlRequest.scan_name required")
+    return out

capo_codeguru_security/types/create_upload_url_response.py

@@ -0,0 +1,59 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#CreateUploadUrlResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_codeguru_security.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.request_header_map
+    import capo_codeguru_security.types.s3_url
+    import capo_codeguru_security.types.uuid
+
+
+class CreateUploadUrlResponse(TypedDict, closed=True):
+    s3_url: "capo_codeguru_security.types.s3_url.S3Url"
+    """<p>A pre-signed S3 URL. You can upload the code file you want to scan with the required <code>requestHeaders</code> using any HTTP client.</p>"""
+    request_headers: "capo_codeguru_security.types.request_header_map.RequestHeaderMap"
+    """<p>A set of key-value pairs that contain the required headers when uploading your resource.</p>"""
+    code_artifact_id: "capo_codeguru_security.types.uuid.Uuid"
+    """<p>The identifier for the uploaded code resource. Pass this to <code>CreateScan</code> to use the uploaded resources.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CreateUploadUrlResponse) -> dict:
+    out: dict = {}
+    out["s3Url"] = value["s3_url"]
+    import capo_codeguru_security.types.request_header_map
+
+    out["requestHeaders"] = (
+        capo_codeguru_security.types.request_header_map.serialize_json(
+            value["request_headers"]
+        )
+    )
+    out["codeArtifactId"] = value["code_artifact_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> CreateUploadUrlResponse:
+    out: CreateUploadUrlResponse = {}  # type: ignore[typeddict-item]
+    if data.get("s3Url") is not None:
+        out["s3_url"] = data["s3Url"]
+    else:
+        raise DeserializationError("CreateUploadUrlResponse.s3_url required")
+    if data.get("requestHeaders") is not None:
+        import capo_codeguru_security.types.request_header_map
+
+        out["request_headers"] = (
+            capo_codeguru_security.types.request_header_map.deserialize_json(
+                data["requestHeaders"]
+            )
+        )
+    else:
+        raise DeserializationError("CreateUploadUrlResponse.request_headers required")
+    if data.get("codeArtifactId") is not None:
+        out["code_artifact_id"] = data["codeArtifactId"]
+    else:
+        raise DeserializationError("CreateUploadUrlResponse.code_artifact_id required")
+    return out

capo_codeguru_security/types/detector_tags.py

@@ -0,0 +1,14 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#DetectorTags``."""
+
+from typing import TypeAlias
+
+DetectorTags: TypeAlias = list["str"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: DetectorTags) -> list:
+    return list(value)
+
+
+def deserialize_json(data: list) -> DetectorTags:
+    return [item for item in data if item is not None]

capo_codeguru_security/types/encryption_config.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#EncryptionConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.kms_key_arn
+
+
+class EncryptionConfig(TypedDict, closed=True):
+    kms_key_arn: NotRequired["capo_codeguru_security.types.kms_key_arn.KmsKeyArn"]
+    """<p>The KMS key ARN that is used for encryption. If an AWS-managed key is used for encryption, returns empty.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: EncryptionConfig) -> dict:
+    out: dict = {}
+    if "kms_key_arn" in value:
+        out["kmsKeyArn"] = value["kms_key_arn"]
+    return out
+
+
+def deserialize_json(data: dict) -> EncryptionConfig:
+    out: EncryptionConfig = {}  # type: ignore[typeddict-item]
+    if data.get("kmsKeyArn") is not None:
+        out["kms_key_arn"] = data["kmsKeyArn"]
+    return out

capo_codeguru_security/types/error_code.py

@@ -0,0 +1,20 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#ErrorCode``."""
+
+from typing import Literal, TypeAlias, cast
+
+ErrorCode: TypeAlias = Literal[
+    "DUPLICATE_IDENTIFIER",
+    "ITEM_DOES_NOT_EXIST",
+    "INTERNAL_ERROR",
+    "INVALID_FINDING_ID",
+    "INVALID_SCAN_NAME",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ErrorCode) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> ErrorCode:
+    return cast(ErrorCode, data)

capo_codeguru_security/types/error_message.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#ErrorMessage``."""
+
+from typing import TypeAlias
+
+ErrorMessage: TypeAlias = str

capo_codeguru_security/types/file_path.py

@@ -0,0 +1,62 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#FilePath``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.code_snippet
+
+
+class FilePath(TypedDict, closed=True):
+    name: NotRequired["str"]
+    """<p>The name of the file.</p>"""
+    path: NotRequired["str"]
+    """<p>The path to the resource with the security vulnerability.</p>"""
+    start_line: NotRequired["int"]
+    """<p>The first line number of the code snippet where the security vulnerability appears in your code.</p>"""
+    end_line: NotRequired["int"]
+    """<p>The last line number of the code snippet where the security vulnerability appears in your code.</p>"""
+    code_snippet: NotRequired["capo_codeguru_security.types.code_snippet.CodeSnippet"]
+    """<p>A list of <code>CodeLine</code> objects that describe where the security vulnerability appears in your code.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: FilePath) -> dict:
+    out: dict = {}
+    if "name" in value:
+        out["name"] = value["name"]
+    if "path" in value:
+        out["path"] = value["path"]
+    if "start_line" in value:
+        out["startLine"] = value["start_line"]
+    if "end_line" in value:
+        out["endLine"] = value["end_line"]
+    if "code_snippet" in value:
+        import capo_codeguru_security.types.code_snippet
+
+        out["codeSnippet"] = capo_codeguru_security.types.code_snippet.serialize_json(
+            value["code_snippet"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> FilePath:
+    out: FilePath = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    if data.get("path") is not None:
+        out["path"] = data["path"]
+    if data.get("startLine") is not None:
+        out["start_line"] = data["startLine"]
+    if data.get("endLine") is not None:
+        out["end_line"] = data["endLine"]
+    if data.get("codeSnippet") is not None:
+        import capo_codeguru_security.types.code_snippet
+
+        out["code_snippet"] = (
+            capo_codeguru_security.types.code_snippet.deserialize_json(
+                data["codeSnippet"]
+            )
+        )
+    return out

capo_codeguru_security/types/finding.py

@@ -0,0 +1,207 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#Finding``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import datetime
+
+    import capo_codeguru_security.types.detector_tags
+    import capo_codeguru_security.types.remediation
+    import capo_codeguru_security.types.resource
+    import capo_codeguru_security.types.severity
+    import capo_codeguru_security.types.status
+    import capo_codeguru_security.types.vulnerability
+
+
+class Finding(TypedDict, closed=True):
+    created_at: NotRequired["datetime.datetime"]
+    """<p>The time when the finding was created.</p>"""
+    description: NotRequired["str"]
+    """<p>A description of the finding.</p>"""
+    generator_id: NotRequired["str"]
+    """<p>The identifier for the component that generated a finding such as AmazonCodeGuruSecurity.</p>"""
+    id: NotRequired["str"]
+    """<p>The identifier for a finding.</p>"""
+    updated_at: NotRequired["datetime.datetime"]
+    """<p>The time when the finding was last updated. Findings are updated when you remediate them or when the finding code location changes. </p>"""
+    type: NotRequired["str"]
+    """<p>The type of finding. </p>"""
+    status: NotRequired["capo_codeguru_security.types.status.Status"]
+    """<p>The status of the finding. A finding status can be open or closed. </p>"""
+    resource: NotRequired["capo_codeguru_security.types.resource.Resource"]
+    """<p>The resource where Amazon CodeGuru Security detected a finding.</p>"""
+    vulnerability: NotRequired[
+        "capo_codeguru_security.types.vulnerability.Vulnerability"
+    ]
+    """<p>An object that describes the detected security vulnerability.</p>"""
+    severity: NotRequired["capo_codeguru_security.types.severity.Severity"]
+    r"""<p>The severity of the finding. Severity can be critical, high, medium, low, or informational. For information on severity levels, see <a href=\"https://docs.aws.amazon.com/codeguru/latest/security-ug/findings-overview.html#severity-distribution\">Finding severity</a> in the <i>Amazon CodeGuru Security User Guide</i>.</p>"""
+    remediation: NotRequired["capo_codeguru_security.types.remediation.Remediation"]
+    """<p>An object that contains the details about how to remediate a finding.</p>"""
+    title: NotRequired["str"]
+    """<p>The title of the finding.</p>"""
+    detector_tags: NotRequired[
+        "capo_codeguru_security.types.detector_tags.DetectorTags"
+    ]
+    """<p>One or more tags or categorizations that are associated with a detector. These tags are defined by type, programming language, or other classification such as maintainability or consistency.</p>"""
+    detector_id: NotRequired["str"]
+    """<p>The identifier for the detector that detected the finding in your code. A detector is a defined rule based on industry standards and AWS best practices. </p>"""
+    detector_name: NotRequired["str"]
+    """<p>The name of the detector that identified the security vulnerability in your code. </p>"""
+    rule_id: NotRequired["str"]
+    """<p>The identifier for the rule that generated the finding.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Finding) -> dict:
+    out: dict = {}
+    if "created_at" in value:
+        import capo_codeguru_security.types._prelude.timestamp
+
+        out["createdAt"] = (
+            capo_codeguru_security.types._prelude.timestamp.serialize_json(
+                value["created_at"]
+            )
+        )
+    if "description" in value:
+        out["description"] = value["description"]
+    if "generator_id" in value:
+        out["generatorId"] = value["generator_id"]
+    if "id" in value:
+        out["id"] = value["id"]
+    if "updated_at" in value:
+        import capo_codeguru_security.types._prelude.timestamp
+
+        out["updatedAt"] = (
+            capo_codeguru_security.types._prelude.timestamp.serialize_json(
+                value["updated_at"]
+            )
+        )
+    if "type" in value:
+        out["type"] = value["type"]
+    if "status" in value:
+        import capo_codeguru_security.types.status
+
+        out["status"] = capo_codeguru_security.types.status.serialize_json(
+            value["status"]
+        )
+    if "resource" in value:
+        import capo_codeguru_security.types.resource
+
+        out["resource"] = capo_codeguru_security.types.resource.serialize_json(
+            value["resource"]
+        )
+    if "vulnerability" in value:
+        import capo_codeguru_security.types.vulnerability
+
+        out["vulnerability"] = (
+            capo_codeguru_security.types.vulnerability.serialize_json(
+                value["vulnerability"]
+            )
+        )
+    if "severity" in value:
+        import capo_codeguru_security.types.severity
+
+        out["severity"] = capo_codeguru_security.types.severity.serialize_json(
+            value["severity"]
+        )
+    if "remediation" in value:
+        import capo_codeguru_security.types.remediation
+
+        out["remediation"] = capo_codeguru_security.types.remediation.serialize_json(
+            value["remediation"]
+        )
+    if "title" in value:
+        out["title"] = value["title"]
+    if "detector_tags" in value:
+        import capo_codeguru_security.types.detector_tags
+
+        out["detectorTags"] = capo_codeguru_security.types.detector_tags.serialize_json(
+            value["detector_tags"]
+        )
+    if "detector_id" in value:
+        out["detectorId"] = value["detector_id"]
+    if "detector_name" in value:
+        out["detectorName"] = value["detector_name"]
+    if "rule_id" in value:
+        out["ruleId"] = value["rule_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> Finding:
+    out: Finding = {}  # type: ignore[typeddict-item]
+    if data.get("createdAt") is not None:
+        import capo_codeguru_security.types._prelude.timestamp
+
+        out["created_at"] = (
+            capo_codeguru_security.types._prelude.timestamp.deserialize_json(
+                data["createdAt"]
+            )
+        )
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    if data.get("generatorId") is not None:
+        out["generator_id"] = data["generatorId"]
+    if data.get("id") is not None:
+        out["id"] = data["id"]
+    if data.get("updatedAt") is not None:
+        import capo_codeguru_security.types._prelude.timestamp
+
+        out["updated_at"] = (
+            capo_codeguru_security.types._prelude.timestamp.deserialize_json(
+                data["updatedAt"]
+            )
+        )
+    if data.get("type") is not None:
+        out["type"] = data["type"]
+    if data.get("status") is not None:
+        import capo_codeguru_security.types.status
+
+        out["status"] = capo_codeguru_security.types.status.deserialize_json(
+            data["status"]
+        )
+    if data.get("resource") is not None:
+        import capo_codeguru_security.types.resource
+
+        out["resource"] = capo_codeguru_security.types.resource.deserialize_json(
+            data["resource"]
+        )
+    if data.get("vulnerability") is not None:
+        import capo_codeguru_security.types.vulnerability
+
+        out["vulnerability"] = (
+            capo_codeguru_security.types.vulnerability.deserialize_json(
+                data["vulnerability"]
+            )
+        )
+    if data.get("severity") is not None:
+        import capo_codeguru_security.types.severity
+
+        out["severity"] = capo_codeguru_security.types.severity.deserialize_json(
+            data["severity"]
+        )
+    if data.get("remediation") is not None:
+        import capo_codeguru_security.types.remediation
+
+        out["remediation"] = capo_codeguru_security.types.remediation.deserialize_json(
+            data["remediation"]
+        )
+    if data.get("title") is not None:
+        out["title"] = data["title"]
+    if data.get("detectorTags") is not None:
+        import capo_codeguru_security.types.detector_tags
+
+        out["detector_tags"] = (
+            capo_codeguru_security.types.detector_tags.deserialize_json(
+                data["detectorTags"]
+            )
+        )
+    if data.get("detectorId") is not None:
+        out["detector_id"] = data["detectorId"]
+    if data.get("detectorName") is not None:
+        out["detector_name"] = data["detectorName"]
+    if data.get("ruleId") is not None:
+        out["rule_id"] = data["ruleId"]
+    return out

capo_codeguru_security/types/finding_identifier.py

@@ -0,0 +1,33 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#FindingIdentifier``."""
+
+from typing_extensions import TypedDict
+
+from capo_codeguru_security.errors import DeserializationError
+
+
+class FindingIdentifier(TypedDict, closed=True):
+    scan_name: "str"
+    """<p>The name of the scan that generated the finding. </p>"""
+    finding_id: "str"
+    """<p>The identifier for a finding.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: FindingIdentifier) -> dict:
+    out: dict = {}
+    out["scanName"] = value["scan_name"]
+    out["findingId"] = value["finding_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> FindingIdentifier:
+    out: FindingIdentifier = {}  # type: ignore[typeddict-item]
+    if data.get("scanName") is not None:
+        out["scan_name"] = data["scanName"]
+    else:
+        raise DeserializationError("FindingIdentifier.scan_name required")
+    if data.get("findingId") is not None:
+        out["finding_id"] = data["findingId"]
+    else:
+        raise DeserializationError("FindingIdentifier.finding_id required")
+    return out

capo_codeguru_security/types/finding_identifiers.py

@@ -0,0 +1,33 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#FindingIdentifiers``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.finding_identifier
+
+FindingIdentifiers: TypeAlias = list[
+    "capo_codeguru_security.types.finding_identifier.FindingIdentifier"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: FindingIdentifiers) -> list:
+    import capo_codeguru_security.types.finding_identifier
+
+    out: list = []
+    for item in value:
+        out.append(capo_codeguru_security.types.finding_identifier.serialize_json(item))
+    return out
+
+
+def deserialize_json(data: list) -> FindingIdentifiers:
+    import capo_codeguru_security.types.finding_identifier
+
+    out: FindingIdentifiers = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(
+            capo_codeguru_security.types.finding_identifier.deserialize_json(item)
+        )
+    return out

capo_codeguru_security/types/finding_metrics_value_per_severity.py

@@ -0,0 +1,87 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#FindingMetricsValuePerSeverity``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+
+class FindingMetricsValuePerSeverity(TypedDict, closed=True):
+    info: NotRequired["float"]
+    """<p>A numeric value corresponding to an informational finding.</p>"""
+    low: NotRequired["float"]
+    """<p>A numeric value corresponding to a low severity finding.</p>"""
+    medium: NotRequired["float"]
+    """<p>A numeric value corresponding to a medium severity finding.</p>"""
+    high: NotRequired["float"]
+    """<p>A numeric value corresponding to a high severity finding.</p>"""
+    critical: NotRequired["float"]
+    """<p>A numeric value corresponding to a critical finding.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: FindingMetricsValuePerSeverity) -> dict:
+    out: dict = {}
+    if "info" in value:
+        out["info"] = (
+            "NaN"
+            if value["info"] != value["info"]
+            else "Infinity"
+            if value["info"] == float("inf")
+            else "-Infinity"
+            if value["info"] == float("-inf")
+            else value["info"]
+        )
+    if "low" in value:
+        out["low"] = (
+            "NaN"
+            if value["low"] != value["low"]
+            else "Infinity"
+            if value["low"] == float("inf")
+            else "-Infinity"
+            if value["low"] == float("-inf")
+            else value["low"]
+        )
+    if "medium" in value:
+        out["medium"] = (
+            "NaN"
+            if value["medium"] != value["medium"]
+            else "Infinity"
+            if value["medium"] == float("inf")
+            else "-Infinity"
+            if value["medium"] == float("-inf")
+            else value["medium"]
+        )
+    if "high" in value:
+        out["high"] = (
+            "NaN"
+            if value["high"] != value["high"]
+            else "Infinity"
+            if value["high"] == float("inf")
+            else "-Infinity"
+            if value["high"] == float("-inf")
+            else value["high"]
+        )
+    if "critical" in value:
+        out["critical"] = (
+            "NaN"
+            if value["critical"] != value["critical"]
+            else "Infinity"
+            if value["critical"] == float("inf")
+            else "-Infinity"
+            if value["critical"] == float("-inf")
+            else value["critical"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> FindingMetricsValuePerSeverity:
+    out: FindingMetricsValuePerSeverity = {}  # type: ignore[typeddict-item]
+    if data.get("info") is not None:
+        out["info"] = float(data["info"])
+    if data.get("low") is not None:
+        out["low"] = float(data["low"])
+    if data.get("medium") is not None:
+        out["medium"] = float(data["medium"])
+    if data.get("high") is not None:
+        out["high"] = float(data["high"])
+    if data.get("critical") is not None:
+        out["critical"] = float(data["critical"])
+    return out

capo_codeguru_security/types/findings.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#Findings``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.finding
+
+Findings: TypeAlias = list["capo_codeguru_security.types.finding.Finding"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Findings) -> list:
+    import capo_codeguru_security.types.finding
+
+    out: list = []
+    for item in value:
+        out.append(capo_codeguru_security.types.finding.serialize_json(item))
+    return out
+
+
+def deserialize_json(data: list) -> Findings:
+    import capo_codeguru_security.types.finding
+
+    out: Findings = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(capo_codeguru_security.types.finding.deserialize_json(item))
+    return out

capo_codeguru_security/types/findings_metric_list.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#FindingsMetricList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.account_findings_metric
+
+FindingsMetricList: TypeAlias = list[
+    "capo_codeguru_security.types.account_findings_metric.AccountFindingsMetric"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: FindingsMetricList) -> list:
+    import capo_codeguru_security.types.account_findings_metric
+
+    out: list = []
+    for item in value:
+        out.append(
+            capo_codeguru_security.types.account_findings_metric.serialize_json(item)
+        )
+    return out
+
+
+def deserialize_json(data: list) -> FindingsMetricList:
+    import capo_codeguru_security.types.account_findings_metric
+
+    out: FindingsMetricList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(
+            capo_codeguru_security.types.account_findings_metric.deserialize_json(item)
+        )
+    return out

capo_codeguru_security/types/get_account_configuration_request.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#GetAccountConfigurationRequest``."""
+
+from typing_extensions import TypedDict
+
+
+class GetAccountConfigurationRequest(TypedDict, closed=True):
+    pass
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetAccountConfigurationRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetAccountConfigurationRequest:
+    out: GetAccountConfigurationRequest = {}  # type: ignore[typeddict-item]
+    return out