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

capo_codeguru_security/types/account_findings_metric.py

@@ -0,0 +1,118 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#AccountFindingsMetric``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import datetime
+
+    import capo_codeguru_security.types.finding_metrics_value_per_severity
+
+
+class AccountFindingsMetric(TypedDict, closed=True):
+    date: NotRequired["datetime.datetime"]
+    """<p>The date from which the findings metrics were retrieved.</p>"""
+    new_findings: NotRequired[
+        "capo_codeguru_security.types.finding_metrics_value_per_severity.FindingMetricsValuePerSeverity"
+    ]
+    """<p>The number of new findings of each severity on the specified date.</p>"""
+    closed_findings: NotRequired[
+        "capo_codeguru_security.types.finding_metrics_value_per_severity.FindingMetricsValuePerSeverity"
+    ]
+    """<p>The number of closed findings of each severity on the specified date.</p>"""
+    open_findings: NotRequired[
+        "capo_codeguru_security.types.finding_metrics_value_per_severity.FindingMetricsValuePerSeverity"
+    ]
+    """<p>The number of open findings of each severity as of the specified date.</p>"""
+    mean_time_to_close: NotRequired[
+        "capo_codeguru_security.types.finding_metrics_value_per_severity.FindingMetricsValuePerSeverity"
+    ]
+    """<p>The average time in days it takes to close findings of each severity as of a specified date.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AccountFindingsMetric) -> dict:
+    out: dict = {}
+    if "date" in value:
+        import capo_codeguru_security.types._prelude.timestamp
+
+        out["date"] = capo_codeguru_security.types._prelude.timestamp.serialize_json(
+            value["date"]
+        )
+    if "new_findings" in value:
+        import capo_codeguru_security.types.finding_metrics_value_per_severity
+
+        out["newFindings"] = (
+            capo_codeguru_security.types.finding_metrics_value_per_severity.serialize_json(
+                value["new_findings"]
+            )
+        )
+    if "closed_findings" in value:
+        import capo_codeguru_security.types.finding_metrics_value_per_severity
+
+        out["closedFindings"] = (
+            capo_codeguru_security.types.finding_metrics_value_per_severity.serialize_json(
+                value["closed_findings"]
+            )
+        )
+    if "open_findings" in value:
+        import capo_codeguru_security.types.finding_metrics_value_per_severity
+
+        out["openFindings"] = (
+            capo_codeguru_security.types.finding_metrics_value_per_severity.serialize_json(
+                value["open_findings"]
+            )
+        )
+    if "mean_time_to_close" in value:
+        import capo_codeguru_security.types.finding_metrics_value_per_severity
+
+        out["meanTimeToClose"] = (
+            capo_codeguru_security.types.finding_metrics_value_per_severity.serialize_json(
+                value["mean_time_to_close"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> AccountFindingsMetric:
+    out: AccountFindingsMetric = {}  # type: ignore[typeddict-item]
+    if data.get("date") is not None:
+        import capo_codeguru_security.types._prelude.timestamp
+
+        out["date"] = capo_codeguru_security.types._prelude.timestamp.deserialize_json(
+            data["date"]
+        )
+    if data.get("newFindings") is not None:
+        import capo_codeguru_security.types.finding_metrics_value_per_severity
+
+        out["new_findings"] = (
+            capo_codeguru_security.types.finding_metrics_value_per_severity.deserialize_json(
+                data["newFindings"]
+            )
+        )
+    if data.get("closedFindings") is not None:
+        import capo_codeguru_security.types.finding_metrics_value_per_severity
+
+        out["closed_findings"] = (
+            capo_codeguru_security.types.finding_metrics_value_per_severity.deserialize_json(
+                data["closedFindings"]
+            )
+        )
+    if data.get("openFindings") is not None:
+        import capo_codeguru_security.types.finding_metrics_value_per_severity
+
+        out["open_findings"] = (
+            capo_codeguru_security.types.finding_metrics_value_per_severity.deserialize_json(
+                data["openFindings"]
+            )
+        )
+    if data.get("meanTimeToClose") is not None:
+        import capo_codeguru_security.types.finding_metrics_value_per_severity
+
+        out["mean_time_to_close"] = (
+            capo_codeguru_security.types.finding_metrics_value_per_severity.deserialize_json(
+                data["meanTimeToClose"]
+            )
+        )
+    return out

capo_codeguru_security/types/analysis_type.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#AnalysisType``."""
+
+from typing import Literal, TypeAlias, cast
+
+AnalysisType: TypeAlias = Literal[
+    "Security",
+    "All",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AnalysisType) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> AnalysisType:
+    return cast(AnalysisType, data)

capo_codeguru_security/types/batch_get_findings_error.py

@@ -0,0 +1,61 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#BatchGetFindingsError``."""
+
+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.error_code
+    import capo_codeguru_security.types.scan_name
+
+
+class BatchGetFindingsError(TypedDict, closed=True):
+    scan_name: "capo_codeguru_security.types.scan_name.ScanName"
+    """<p>The name of the scan that generated the finding.</p>"""
+    finding_id: "str"
+    """<p>The finding ID of the finding that was not fetched.</p>"""
+    error_code: "capo_codeguru_security.types.error_code.ErrorCode"
+    """<p>A code associated with the type of error.</p>"""
+    message: "str"
+    """<p>Describes the error.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: BatchGetFindingsError) -> dict:
+    out: dict = {}
+    out["scanName"] = value["scan_name"]
+    out["findingId"] = value["finding_id"]
+    import capo_codeguru_security.types.error_code
+
+    out["errorCode"] = capo_codeguru_security.types.error_code.serialize_json(
+        value["error_code"]
+    )
+    out["message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> BatchGetFindingsError:
+    out: BatchGetFindingsError = {}  # type: ignore[typeddict-item]
+    if data.get("scanName") is not None:
+        out["scan_name"] = data["scanName"]
+    else:
+        raise DeserializationError("BatchGetFindingsError.scan_name required")
+    if data.get("findingId") is not None:
+        out["finding_id"] = data["findingId"]
+    else:
+        raise DeserializationError("BatchGetFindingsError.finding_id required")
+    if data.get("errorCode") is not None:
+        import capo_codeguru_security.types.error_code
+
+        out["error_code"] = capo_codeguru_security.types.error_code.deserialize_json(
+            data["errorCode"]
+        )
+    else:
+        raise DeserializationError("BatchGetFindingsError.error_code required")
+    if data.get("message") is not None:
+        out["message"] = data["message"]
+    else:
+        raise DeserializationError("BatchGetFindingsError.message required")
+    return out

capo_codeguru_security/types/batch_get_findings_errors.py

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

capo_codeguru_security/types/batch_get_findings_request.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#BatchGetFindingsRequest``."""
+
+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.finding_identifiers
+
+
+class BatchGetFindingsRequest(TypedDict, closed=True):
+    finding_identifiers: (
+        "capo_codeguru_security.types.finding_identifiers.FindingIdentifiers"
+    )
+    """<p>A list of finding identifiers. Each identifier consists of a <code>scanName</code> and a <code>findingId</code>. You retrieve the <code>findingId</code> when you call <code>GetFindings</code>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: BatchGetFindingsRequest) -> dict:
+    out: dict = {}
+    import capo_codeguru_security.types.finding_identifiers
+
+    out["findingIdentifiers"] = (
+        capo_codeguru_security.types.finding_identifiers.serialize_json(
+            value["finding_identifiers"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> BatchGetFindingsRequest:
+    out: BatchGetFindingsRequest = {}  # type: ignore[typeddict-item]
+    if data.get("findingIdentifiers") is not None:
+        import capo_codeguru_security.types.finding_identifiers
+
+        out["finding_identifiers"] = (
+            capo_codeguru_security.types.finding_identifiers.deserialize_json(
+                data["findingIdentifiers"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "BatchGetFindingsRequest.finding_identifiers required"
+        )
+    return out

capo_codeguru_security/types/batch_get_findings_response.py

@@ -0,0 +1,61 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#BatchGetFindingsResponse``."""
+
+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.batch_get_findings_errors
+    import capo_codeguru_security.types.findings
+
+
+class BatchGetFindingsResponse(TypedDict, closed=True):
+    findings: "capo_codeguru_security.types.findings.Findings"
+    """<p> A list of all findings which were successfully fetched.</p>"""
+    failed_findings: (
+        "capo_codeguru_security.types.batch_get_findings_errors.BatchGetFindingsErrors"
+    )
+    """<p>A list of errors for individual findings which were not fetched. Each BatchGetFindingsError contains the <code>scanName</code>, <code>findingId</code>, <code>errorCode</code> and error <code>message</code>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: BatchGetFindingsResponse) -> dict:
+    out: dict = {}
+    import capo_codeguru_security.types.findings
+
+    out["findings"] = capo_codeguru_security.types.findings.serialize_json(
+        value["findings"]
+    )
+    import capo_codeguru_security.types.batch_get_findings_errors
+
+    out["failedFindings"] = (
+        capo_codeguru_security.types.batch_get_findings_errors.serialize_json(
+            value["failed_findings"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> BatchGetFindingsResponse:
+    out: BatchGetFindingsResponse = {}  # type: ignore[typeddict-item]
+    if data.get("findings") is not None:
+        import capo_codeguru_security.types.findings
+
+        out["findings"] = capo_codeguru_security.types.findings.deserialize_json(
+            data["findings"]
+        )
+    else:
+        raise DeserializationError("BatchGetFindingsResponse.findings required")
+    if data.get("failedFindings") is not None:
+        import capo_codeguru_security.types.batch_get_findings_errors
+
+        out["failed_findings"] = (
+            capo_codeguru_security.types.batch_get_findings_errors.deserialize_json(
+                data["failedFindings"]
+            )
+        )
+    else:
+        raise DeserializationError("BatchGetFindingsResponse.failed_findings required")
+    return out

capo_codeguru_security/types/categories_with_most_findings.py

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

capo_codeguru_security/types/category_with_finding_num.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#CategoryWithFindingNum``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+
+class CategoryWithFindingNum(TypedDict, closed=True):
+    category_name: NotRequired["str"]
+    """<p>The name of the finding category. A finding category is determined by the detector that detected the finding.</p>"""
+    finding_number: NotRequired["int"]
+    """<p>The number of open findings in the category.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CategoryWithFindingNum) -> dict:
+    out: dict = {}
+    if "category_name" in value:
+        out["categoryName"] = value["category_name"]
+    if "finding_number" in value:
+        out["findingNumber"] = value["finding_number"]
+    return out
+
+
+def deserialize_json(data: dict) -> CategoryWithFindingNum:
+    out: CategoryWithFindingNum = {}  # type: ignore[typeddict-item]
+    if data.get("categoryName") is not None:
+        out["category_name"] = data["categoryName"]
+    if data.get("findingNumber") is not None:
+        out["finding_number"] = data["findingNumber"]
+    return out

capo_codeguru_security/types/client_token.py

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

capo_codeguru_security/types/code_line.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#CodeLine``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+
+class CodeLine(TypedDict, closed=True):
+    number: NotRequired["int"]
+    """<p>The code line number.</p>"""
+    content: NotRequired["str"]
+    """<p>The code that contains a vulnerability.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CodeLine) -> dict:
+    out: dict = {}
+    if "number" in value:
+        out["number"] = value["number"]
+    if "content" in value:
+        out["content"] = value["content"]
+    return out
+
+
+def deserialize_json(data: dict) -> CodeLine:
+    out: CodeLine = {}  # type: ignore[typeddict-item]
+    if data.get("number") is not None:
+        out["number"] = data["number"]
+    if data.get("content") is not None:
+        out["content"] = data["content"]
+    return out

capo_codeguru_security/types/code_snippet.py

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

capo_codeguru_security/types/create_scan_request.py

@@ -0,0 +1,101 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#CreateScanRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codeguru_security.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.analysis_type
+    import capo_codeguru_security.types.client_token
+    import capo_codeguru_security.types.resource_id
+    import capo_codeguru_security.types.scan_name
+    import capo_codeguru_security.types.scan_type
+    import capo_codeguru_security.types.tag_map
+
+
+class CreateScanRequest(TypedDict, closed=True):
+    client_token: NotRequired["capo_codeguru_security.types.client_token.ClientToken"]
+    """<p>The idempotency token for the request. Amazon CodeGuru Security uses this value to prevent the accidental creation of duplicate scans if there are failures and retries.</p>"""
+    resource_id: "capo_codeguru_security.types.resource_id.ResourceId"
+    """<p>The identifier for the resource object to be scanned.</p>"""
+    scan_name: "capo_codeguru_security.types.scan_name.ScanName"
+    """<p>The unique name that CodeGuru Security uses to track revisions across multiple scans of the same resource. Only allowed for a <code>STANDARD</code> scan type. </p>"""
+    scan_type: NotRequired["capo_codeguru_security.types.scan_type.ScanType"]
+    """<p>The type of scan, either <code>Standard</code> or <code>Express</code>. Defaults to <code>Standard</code> type if missing.</p> <p> <code>Express</code> scans run on limited resources and use a limited set of detectors to analyze your code in near-real time. <code>Standard</code> scans have standard resource limits and use the full set of detectors to analyze your code.</p>"""
+    analysis_type: NotRequired[
+        "capo_codeguru_security.types.analysis_type.AnalysisType"
+    ]
+    """<p>The type of analysis you want CodeGuru Security to perform in the scan, either <code>Security</code> or <code>All</code>. The <code>Security</code> type only generates findings related to security. The <code>All</code> type generates both security findings and quality findings. Defaults to <code>Security</code> type if missing.</p>"""
+    tags: NotRequired["capo_codeguru_security.types.tag_map.TagMap"]
+    """<p>An array of key-value pairs used to tag a scan. A tag is a custom attribute label with two parts:</p> <ul> <li> <p>A tag key. For example, <code>CostCenter</code>, <code>Environment</code>, or <code>Secret</code>. Tag keys are case sensitive.</p> </li> <li> <p>An optional tag value field. For example, <code>111122223333</code>, <code>Production</code>, or a team name. Omitting the tag value is the same as using an empty string. Tag values are case sensitive.</p> </li> </ul>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CreateScanRequest) -> dict:
+    out: dict = {}
+    if "client_token" in value:
+        out["clientToken"] = value["client_token"]
+    import capo_codeguru_security.types.resource_id
+
+    out["resourceId"] = capo_codeguru_security.types.resource_id.serialize_json(
+        value["resource_id"]
+    )
+    out["scanName"] = value["scan_name"]
+    if "scan_type" in value:
+        import capo_codeguru_security.types.scan_type
+
+        out["scanType"] = capo_codeguru_security.types.scan_type.serialize_json(
+            value["scan_type"]
+        )
+    if "analysis_type" in value:
+        import capo_codeguru_security.types.analysis_type
+
+        out["analysisType"] = capo_codeguru_security.types.analysis_type.serialize_json(
+            value["analysis_type"]
+        )
+    if "tags" in value:
+        import capo_codeguru_security.types.tag_map
+
+        out["tags"] = capo_codeguru_security.types.tag_map.serialize_json(value["tags"])
+    return out
+
+
+def deserialize_json(data: dict) -> CreateScanRequest:
+    out: CreateScanRequest = {}  # type: ignore[typeddict-item]
+    if data.get("clientToken") is not None:
+        out["client_token"] = data["clientToken"]
+    if data.get("resourceId") is not None:
+        import capo_codeguru_security.types.resource_id
+
+        out["resource_id"] = capo_codeguru_security.types.resource_id.deserialize_json(
+            data["resourceId"]
+        )
+    else:
+        raise DeserializationError("CreateScanRequest.resource_id required")
+    if data.get("scanName") is not None:
+        out["scan_name"] = data["scanName"]
+    else:
+        raise DeserializationError("CreateScanRequest.scan_name required")
+    if data.get("scanType") is not None:
+        import capo_codeguru_security.types.scan_type
+
+        out["scan_type"] = capo_codeguru_security.types.scan_type.deserialize_json(
+            data["scanType"]
+        )
+    if data.get("analysisType") is not None:
+        import capo_codeguru_security.types.analysis_type
+
+        out["analysis_type"] = (
+            capo_codeguru_security.types.analysis_type.deserialize_json(
+                data["analysisType"]
+            )
+        )
+    if data.get("tags") is not None:
+        import capo_codeguru_security.types.tag_map
+
+        out["tags"] = capo_codeguru_security.types.tag_map.deserialize_json(
+            data["tags"]
+        )
+    return out

capo_codeguru_security/types/create_scan_response.py

@@ -0,0 +1,78 @@
+"""Generated from Smithy shape ``com.amazonaws.codegurusecurity#CreateScanResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codeguru_security.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codeguru_security.types.resource_id
+    import capo_codeguru_security.types.scan_name
+    import capo_codeguru_security.types.scan_name_arn
+    import capo_codeguru_security.types.scan_state
+    import capo_codeguru_security.types.uuid
+
+
+class CreateScanResponse(TypedDict, closed=True):
+    scan_name: "capo_codeguru_security.types.scan_name.ScanName"
+    """<p>The name of the scan.</p>"""
+    run_id: "capo_codeguru_security.types.uuid.Uuid"
+    """<p>UUID that identifies the individual scan run.</p>"""
+    resource_id: "capo_codeguru_security.types.resource_id.ResourceId"
+    """<p>The identifier for the resource object that contains resources that were scanned.</p>"""
+    scan_state: "capo_codeguru_security.types.scan_state.ScanState"
+    """<p>The current state of the scan. Returns either <code>InProgress</code>, <code>Successful</code>, or <code>Failed</code>.</p>"""
+    scan_name_arn: NotRequired["capo_codeguru_security.types.scan_name_arn.ScanNameArn"]
+    """<p>The ARN for the scan name.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CreateScanResponse) -> dict:
+    out: dict = {}
+    out["scanName"] = value["scan_name"]
+    out["runId"] = value["run_id"]
+    import capo_codeguru_security.types.resource_id
+
+    out["resourceId"] = capo_codeguru_security.types.resource_id.serialize_json(
+        value["resource_id"]
+    )
+    import capo_codeguru_security.types.scan_state
+
+    out["scanState"] = capo_codeguru_security.types.scan_state.serialize_json(
+        value["scan_state"]
+    )
+    if "scan_name_arn" in value:
+        out["scanNameArn"] = value["scan_name_arn"]
+    return out
+
+
+def deserialize_json(data: dict) -> CreateScanResponse:
+    out: CreateScanResponse = {}  # type: ignore[typeddict-item]
+    if data.get("scanName") is not None:
+        out["scan_name"] = data["scanName"]
+    else:
+        raise DeserializationError("CreateScanResponse.scan_name required")
+    if data.get("runId") is not None:
+        out["run_id"] = data["runId"]
+    else:
+        raise DeserializationError("CreateScanResponse.run_id required")
+    if data.get("resourceId") is not None:
+        import capo_codeguru_security.types.resource_id
+
+        out["resource_id"] = capo_codeguru_security.types.resource_id.deserialize_json(
+            data["resourceId"]
+        )
+    else:
+        raise DeserializationError("CreateScanResponse.resource_id required")
+    if data.get("scanState") is not None:
+        import capo_codeguru_security.types.scan_state
+
+        out["scan_state"] = capo_codeguru_security.types.scan_state.deserialize_json(
+            data["scanState"]
+        )
+    else:
+        raise DeserializationError("CreateScanResponse.scan_state required")
+    if data.get("scanNameArn") is not None:
+        out["scan_name_arn"] = data["scanNameArn"]
+    return out