capo-codebuild 0.1.0__py3-none-any.whl

capo_codebuild/types/project_build_batch_config.py

@@ -0,0 +1,86 @@
+"""Generated from Smithy shape ``com.amazonaws.codebuild#ProjectBuildBatchConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codebuild.types.batch_report_mode_type
+    import capo_codebuild.types.batch_restrictions
+    import capo_codebuild.types.non_empty_string
+    import capo_codebuild.types.wrapper_boolean
+    import capo_codebuild.types.wrapper_int
+
+
+class ProjectBuildBatchConfig(TypedDict, closed=True):
+    service_role: NotRequired["capo_codebuild.types.non_empty_string.NonEmptyString"]
+    """<p>Specifies the service role ARN for the batch build project.</p>"""
+    combine_artifacts: NotRequired[
+        "capo_codebuild.types.wrapper_boolean.WrapperBoolean"
+    ]
+    """<p>Specifies if the build artifacts for the batch build should be combined into a single artifact location.</p>"""
+    restrictions: NotRequired[
+        "capo_codebuild.types.batch_restrictions.BatchRestrictions"
+    ]
+    """<p>A <code>BatchRestrictions</code> object that specifies the restrictions for the batch build.</p>"""
+    timeout_in_mins: NotRequired["capo_codebuild.types.wrapper_int.WrapperInt"]
+    """<p>Specifies the maximum amount of time, in minutes, that the batch build must be completed in.</p>"""
+    batch_report_mode: NotRequired[
+        "capo_codebuild.types.batch_report_mode_type.BatchReportModeType"
+    ]
+    """<p>Specifies how build status reports are sent to the source provider for the batch build. This property is only used when the source provider for your project is Bitbucket, GitHub, or GitHub Enterprise, and your project is configured to report build statuses to the source provider.</p> <dl> <dt>REPORT_AGGREGATED_BATCH</dt> <dd> <p>(Default) Aggregate all of the build statuses into a single status report.</p> </dd> <dt>REPORT_INDIVIDUAL_BUILDS</dt> <dd> <p>Send a separate status report for each individual build.</p> </dd> </dl>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ProjectBuildBatchConfig) -> dict:
+    out: dict = {}
+    if "service_role" in value:
+        out["serviceRole"] = value["service_role"]
+    if "combine_artifacts" in value:
+        out["combineArtifacts"] = value["combine_artifacts"]
+    if "restrictions" in value:
+        import capo_codebuild.types.batch_restrictions
+
+        out["restrictions"] = (
+            capo_codebuild.types.batch_restrictions.serialize_aws_json_1_1(
+                value["restrictions"]
+            )
+        )
+    if "timeout_in_mins" in value:
+        out["timeoutInMins"] = value["timeout_in_mins"]
+    if "batch_report_mode" in value:
+        import capo_codebuild.types.batch_report_mode_type
+
+        out["batchReportMode"] = (
+            capo_codebuild.types.batch_report_mode_type.serialize_aws_json_1_1(
+                value["batch_report_mode"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> ProjectBuildBatchConfig:
+    out: ProjectBuildBatchConfig = {}  # type: ignore[typeddict-item]
+    if data.get("serviceRole") is not None:
+        out["service_role"] = data["serviceRole"]
+    if data.get("combineArtifacts") is not None:
+        out["combine_artifacts"] = data["combineArtifacts"]
+    if data.get("restrictions") is not None:
+        import capo_codebuild.types.batch_restrictions
+
+        out["restrictions"] = (
+            capo_codebuild.types.batch_restrictions.deserialize_aws_json_1_1(
+                data["restrictions"]
+            )
+        )
+    if data.get("timeoutInMins") is not None:
+        out["timeout_in_mins"] = data["timeoutInMins"]
+    if data.get("batchReportMode") is not None:
+        import capo_codebuild.types.batch_report_mode_type
+
+        out["batch_report_mode"] = (
+            capo_codebuild.types.batch_report_mode_type.deserialize_aws_json_1_1(
+                data["batchReportMode"]
+            )
+        )
+    return out

capo_codebuild/types/project_cache.py

@@ -0,0 +1,67 @@
+"""Generated from Smithy shape ``com.amazonaws.codebuild#ProjectCache``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codebuild.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codebuild.types.cache_type
+    import capo_codebuild.types.project_cache_modes
+    import capo_codebuild.types.string
+
+
+class ProjectCache(TypedDict, closed=True):
+    type: "capo_codebuild.types.cache_type.CacheType"
+    """<p>The type of cache used by the build project. Valid values include:</p> <ul> <li> <p> <code>NO_CACHE</code>: The build project does not use any cache.</p> </li> <li> <p> <code>S3</code>: The build project reads and writes from and to S3.</p> </li> <li> <p> <code>LOCAL</code>: The build project stores a cache locally on a build host that is only available to that build host.</p> </li> </ul>"""
+    location: NotRequired["capo_codebuild.types.string.String"]
+    """<p>Information about the cache location: </p> <ul> <li> <p> <code>NO_CACHE</code> or <code>LOCAL</code>: This value is ignored.</p> </li> <li> <p> <code>S3</code>: This is the S3 bucket name/prefix.</p> </li> </ul>"""
+    modes: NotRequired["capo_codebuild.types.project_cache_modes.ProjectCacheModes"]
+    """<p>An array of strings that specify the local cache modes. You can use one or more local cache modes at the same time. This is only used for <code>LOCAL</code> cache types.</p> <p>Possible values are:</p> <dl> <dt>LOCAL_SOURCE_CACHE</dt> <dd> <p>Caches Git metadata for primary and secondary sources. After the cache is created, subsequent builds pull only the change between commits. This mode is a good choice for projects with a clean working directory and a source that is a large Git repository. If you choose this option and your project does not use a Git repository (GitHub, GitHub Enterprise, or Bitbucket), the option is ignored. </p> </dd> <dt>LOCAL_DOCKER_LAYER_CACHE</dt> <dd> <p>Caches existing Docker layers. This mode is a good choice for projects that build or pull large Docker images. It can prevent the performance issues caused by pulling large Docker images down from the network. </p> <note> <ul> <li> <p>You can use a Docker layer cache in the Linux environment only. </p> </li> <li> <p>The <code>privileged</code> flag must be set so that your project has the required Docker permissions. </p> </li> <li> <p>You should consider the security implications before you use a Docker layer cache. </p> </li> </ul> </note> </dd> <dt>LOCAL_CUSTOM_CACHE</dt> <dd> <p>Caches directories you specify in the buildspec file. This mode is a good choice if your build scenario is not suited to one of the other three local cache modes. If you use a custom cache: </p> <ul> <li> <p>Only directories can be specified for caching. You cannot specify individual files. </p> </li> <li> <p>Symlinks are used to reference cached directories. </p> </li> <li> <p>Cached directories are linked to your build before it downloads its project sources. Cached items are overridden if a source item has the same name. Directories are specified using cache paths in the buildspec file. </p> </li> </ul> </dd> </dl>"""
+    cache_namespace: NotRequired["capo_codebuild.types.string.String"]
+    r"""<p>Defines the scope of the cache. You can use this namespace to share a cache across multiple projects. For more information, see <a href=\"https://docs.aws.amazon.com/codebuild/latest/userguide/caching-s3.html#caching-s3-sharing\">Cache sharing between projects</a> in the <i>CodeBuild User Guide</i>.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ProjectCache) -> dict:
+    out: dict = {}
+    import capo_codebuild.types.cache_type
+
+    out["type"] = capo_codebuild.types.cache_type.serialize_aws_json_1_1(value["type"])
+    if "location" in value:
+        out["location"] = value["location"]
+    if "modes" in value:
+        import capo_codebuild.types.project_cache_modes
+
+        out["modes"] = capo_codebuild.types.project_cache_modes.serialize_aws_json_1_1(
+            value["modes"]
+        )
+    if "cache_namespace" in value:
+        out["cacheNamespace"] = value["cache_namespace"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> ProjectCache:
+    out: ProjectCache = {}  # type: ignore[typeddict-item]
+    if data.get("type") is not None:
+        import capo_codebuild.types.cache_type
+
+        out["type"] = capo_codebuild.types.cache_type.deserialize_aws_json_1_1(
+            data["type"]
+        )
+    else:
+        raise DeserializationError("ProjectCache.type required")
+    if data.get("location") is not None:
+        out["location"] = data["location"]
+    if data.get("modes") is not None:
+        import capo_codebuild.types.project_cache_modes
+
+        out["modes"] = (
+            capo_codebuild.types.project_cache_modes.deserialize_aws_json_1_1(
+                data["modes"]
+            )
+        )
+    if data.get("cacheNamespace") is not None:
+        out["cache_namespace"] = data["cacheNamespace"]
+    return out

capo_codebuild/types/project_cache_modes.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.codebuild#ProjectCacheModes``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codebuild.types.cache_mode
+
+ProjectCacheModes: TypeAlias = list["capo_codebuild.types.cache_mode.CacheMode"]
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ProjectCacheModes) -> list:
+    import capo_codebuild.types.cache_mode
+
+    out: list = []
+    for item in value:
+        out.append(capo_codebuild.types.cache_mode.serialize_aws_json_1_1(item))
+    return out
+
+
+def deserialize_aws_json_1_1(data: list) -> ProjectCacheModes:
+    import capo_codebuild.types.cache_mode
+
+    out: ProjectCacheModes = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(capo_codebuild.types.cache_mode.deserialize_aws_json_1_1(item))
+    return out

capo_codebuild/types/project_description.py

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

capo_codebuild/types/project_environment.py

@@ -0,0 +1,195 @@
+"""Generated from Smithy shape ``com.amazonaws.codebuild#ProjectEnvironment``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codebuild.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codebuild.types.compute_configuration
+    import capo_codebuild.types.compute_type
+    import capo_codebuild.types.docker_server
+    import capo_codebuild.types.environment_type
+    import capo_codebuild.types.environment_variables
+    import capo_codebuild.types.image_pull_credentials_type
+    import capo_codebuild.types.non_empty_string
+    import capo_codebuild.types.project_fleet
+    import capo_codebuild.types.registry_credential
+    import capo_codebuild.types.string
+    import capo_codebuild.types.wrapper_boolean
+
+
+class ProjectEnvironment(TypedDict, closed=True):
+    type: "capo_codebuild.types.environment_type.EnvironmentType"
+    r"""<p>The type of build environment to use for related builds.</p> <note> <p>If you're using compute fleets during project creation, <code>type</code> will be ignored.</p> </note> <p>For more information, see <a href=\"https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html\">Build environment compute types</a> in the <i>CodeBuild user guide</i>.</p>"""
+    image: "capo_codebuild.types.non_empty_string.NonEmptyString"
+    r"""<p>The image tag or image digest that identifies the Docker image to use for this build project. Use the following formats:</p> <ul> <li> <p>For an image tag: <code><registry>/<repository>:<tag></code>. For example, in the Docker repository that CodeBuild uses to manage its Docker images, this would be <code>aws/codebuild/standard:4.0</code>. </p> </li> <li> <p>For an image digest: <code><registry>/<repository>@<digest></code>. For example, to specify an image with the digest \"sha256:cbbf2f9a99b47fc460d422812b6a5adff7dfee951d8fa2e4a98caa0382cfbdbf,\" use <code><registry>/<repository>@sha256:cbbf2f9a99b47fc460d422812b6a5adff7dfee951d8fa2e4a98caa0382cfbdbf</code>.</p> </li> </ul> <p>For more information, see <a href=\"https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html\">Docker images provided by CodeBuild</a> in the <i>CodeBuild user guide</i>.</p>"""
+    compute_type: "capo_codebuild.types.compute_type.ComputeType"
+    r"""<p>Information about the compute resources the build project uses. Available values include:</p> <ul> <li> <p> <code>ATTRIBUTE_BASED_COMPUTE</code>: Specify the amount of vCPUs, memory, disk space, and the type of machine.</p> <note> <p> If you use <code>ATTRIBUTE_BASED_COMPUTE</code>, you must define your attributes by using <code>computeConfiguration</code>. CodeBuild will select the cheapest instance that satisfies your specified attributes. For more information, see <a href=\"https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment-reserved-capacity.types\">Reserved capacity environment types</a> in the <i>CodeBuild User Guide</i>.</p> </note> </li> <li> <p> <code>BUILD_GENERAL1_SMALL</code>: Use up to 4 GiB memory and 2 vCPUs for builds.</p> </li> <li> <p> <code>BUILD_GENERAL1_MEDIUM</code>: Use up to 8 GiB memory and 4 vCPUs for builds.</p> </li> <li> <p> <code>BUILD_GENERAL1_LARGE</code>: Use up to 16 GiB memory and 8 vCPUs for builds, depending on your environment type.</p> </li> <li> <p> <code>BUILD_GENERAL1_XLARGE</code>: Use up to 72 GiB memory and 36 vCPUs for builds, depending on your environment type.</p> </li> <li> <p> <code>BUILD_GENERAL1_2XLARGE</code>: Use up to 144 GiB memory, 72 vCPUs, and 824 GB of SSD storage for builds. This compute type supports Docker images up to 100 GB uncompressed.</p> </li> <li> <p> <code>BUILD_LAMBDA_1GB</code>: Use up to 1 GiB memory for builds. Only available for environment type <code>LINUX_LAMBDA_CONTAINER</code> and <code>ARM_LAMBDA_CONTAINER</code>.</p> </li> <li> <p> <code>BUILD_LAMBDA_2GB</code>: Use up to 2 GiB memory for builds. Only available for environment type <code>LINUX_LAMBDA_CONTAINER</code> and <code>ARM_LAMBDA_CONTAINER</code>.</p> </li> <li> <p> <code>BUILD_LAMBDA_4GB</code>: Use up to 4 GiB memory for builds. Only available for environment type <code>LINUX_LAMBDA_CONTAINER</code> and <code>ARM_LAMBDA_CONTAINER</code>.</p> </li> <li> <p> <code>BUILD_LAMBDA_8GB</code>: Use up to 8 GiB memory for builds. Only available for environment type <code>LINUX_LAMBDA_CONTAINER</code> and <code>ARM_LAMBDA_CONTAINER</code>.</p> </li> <li> <p> <code>BUILD_LAMBDA_10GB</code>: Use up to 10 GiB memory for builds. Only available for environment type <code>LINUX_LAMBDA_CONTAINER</code> and <code>ARM_LAMBDA_CONTAINER</code>.</p> </li> </ul> <p> If you use <code>BUILD_GENERAL1_SMALL</code>: </p> <ul> <li> <p> For environment type <code>LINUX_CONTAINER</code>, you can use up to 4 GiB memory and 2 vCPUs for builds. </p> </li> <li> <p> For environment type <code>LINUX_GPU_CONTAINER</code>, you can use up to 16 GiB memory, 4 vCPUs, and 1 NVIDIA A10G Tensor Core GPU for builds.</p> </li> <li> <p> For environment type <code>ARM_CONTAINER</code>, you can use up to 4 GiB memory and 2 vCPUs on ARM-based processors for builds.</p> </li> </ul> <p> If you use <code>BUILD_GENERAL1_LARGE</code>: </p> <ul> <li> <p> For environment type <code>LINUX_CONTAINER</code>, you can use up to 16 GiB memory and 8 vCPUs for builds. </p> </li> <li> <p> For environment type <code>LINUX_GPU_CONTAINER</code>, you can use up to 255 GiB memory, 32 vCPUs, and 4 NVIDIA Tesla V100 GPUs for builds.</p> </li> <li> <p> For environment type <code>ARM_CONTAINER</code>, you can use up to 16 GiB memory and 8 vCPUs on ARM-based processors for builds.</p> </li> </ul> <p>For more information, see <a href=\"https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html#environment.types\">On-demand environment types</a> in the <i>CodeBuild User Guide.</i> </p>"""
+    compute_configuration: NotRequired[
+        "capo_codebuild.types.compute_configuration.ComputeConfiguration"
+    ]
+    """<p>The compute configuration of the build project. This is only required if <code>computeType</code> is set to <code>ATTRIBUTE_BASED_COMPUTE</code>.</p>"""
+    fleet: NotRequired["capo_codebuild.types.project_fleet.ProjectFleet"]
+    """<p>A ProjectFleet object to use for this build project.</p>"""
+    environment_variables: NotRequired[
+        "capo_codebuild.types.environment_variables.EnvironmentVariables"
+    ]
+    """<p>A set of environment variables to make available to builds for this build project.</p>"""
+    privileged_mode: NotRequired["capo_codebuild.types.wrapper_boolean.WrapperBoolean"]
+    r"""<p>Enables running the Docker daemon inside a Docker container. Set to true only if the build project is used to build Docker images. Otherwise, a build that attempts to interact with the Docker daemon fails. The default setting is <code>false</code>.</p> <p>You can initialize the Docker daemon during the install phase of your build by adding one of the following sets of commands to the install phase of your buildspec file:</p> <p>If the operating system's base image is Ubuntu Linux:</p> <p> <code>- nohup /usr/local/bin/dockerd --host=unix:///var/run/docker.sock --host=tcp://0.0.0.0:2375 --storage-driver=overlay&</code> </p> <p> <code>- timeout 15 sh -c \"until docker info; do echo .; sleep 1; done\"</code> </p> <p>If the operating system's base image is Alpine Linux and the previous command does not work, add the <code>-t</code> argument to <code>timeout</code>:</p> <p> <code>- nohup /usr/local/bin/dockerd --host=unix:///var/run/docker.sock --host=tcp://0.0.0.0:2375 --storage-driver=overlay&</code> </p> <p> <code>- timeout -t 15 sh -c \"until docker info; do echo .; sleep 1; done\"</code> </p>"""
+    certificate: NotRequired["capo_codebuild.types.string.String"]
+    r"""<p>The ARN of the Amazon S3 bucket, path prefix, and object key that contains the PEM-encoded certificate for the build project. For more information, see <a href=\"https://docs.aws.amazon.com/codebuild/latest/userguide/create-project-cli.html#cli.environment.certificate\">certificate</a> in the <i>CodeBuild User Guide</i>.</p>"""
+    registry_credential: NotRequired[
+        "capo_codebuild.types.registry_credential.RegistryCredential"
+    ]
+    """<p> The credentials for access to a private registry.</p>"""
+    image_pull_credentials_type: NotRequired[
+        "capo_codebuild.types.image_pull_credentials_type.ImagePullCredentialsType"
+    ]
+    """<p> The type of credentials CodeBuild uses to pull images in your build. There are two valid values: </p> <ul> <li> <p> <code>CODEBUILD</code> specifies that CodeBuild uses its own credentials. This requires that you modify your ECR repository policy to trust CodeBuild service principal. </p> </li> <li> <p> <code>SERVICE_ROLE</code> specifies that CodeBuild uses your build project's service role. </p> </li> </ul> <p> When you use a cross-account or private registry image, you must use SERVICE_ROLE credentials. When you use an CodeBuild curated image, you must use CODEBUILD credentials. </p>"""
+    docker_server: NotRequired["capo_codebuild.types.docker_server.DockerServer"]
+    """<p>A DockerServer object to use for this build project.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ProjectEnvironment) -> dict:
+    out: dict = {}
+    import capo_codebuild.types.environment_type
+
+    out["type"] = capo_codebuild.types.environment_type.serialize_aws_json_1_1(
+        value["type"]
+    )
+    out["image"] = value["image"]
+    import capo_codebuild.types.compute_type
+
+    out["computeType"] = capo_codebuild.types.compute_type.serialize_aws_json_1_1(
+        value["compute_type"]
+    )
+    if "compute_configuration" in value:
+        import capo_codebuild.types.compute_configuration
+
+        out["computeConfiguration"] = (
+            capo_codebuild.types.compute_configuration.serialize_aws_json_1_1(
+                value["compute_configuration"]
+            )
+        )
+    if "fleet" in value:
+        import capo_codebuild.types.project_fleet
+
+        out["fleet"] = capo_codebuild.types.project_fleet.serialize_aws_json_1_1(
+            value["fleet"]
+        )
+    if "environment_variables" in value:
+        import capo_codebuild.types.environment_variables
+
+        out["environmentVariables"] = (
+            capo_codebuild.types.environment_variables.serialize_aws_json_1_1(
+                value["environment_variables"]
+            )
+        )
+    if "privileged_mode" in value:
+        out["privilegedMode"] = value["privileged_mode"]
+    if "certificate" in value:
+        out["certificate"] = value["certificate"]
+    if "registry_credential" in value:
+        import capo_codebuild.types.registry_credential
+
+        out["registryCredential"] = (
+            capo_codebuild.types.registry_credential.serialize_aws_json_1_1(
+                value["registry_credential"]
+            )
+        )
+    if "image_pull_credentials_type" in value:
+        import capo_codebuild.types.image_pull_credentials_type
+
+        out["imagePullCredentialsType"] = (
+            capo_codebuild.types.image_pull_credentials_type.serialize_aws_json_1_1(
+                value["image_pull_credentials_type"]
+            )
+        )
+    if "docker_server" in value:
+        import capo_codebuild.types.docker_server
+
+        out["dockerServer"] = capo_codebuild.types.docker_server.serialize_aws_json_1_1(
+            value["docker_server"]
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> ProjectEnvironment:
+    out: ProjectEnvironment = {}  # type: ignore[typeddict-item]
+    if data.get("type") is not None:
+        import capo_codebuild.types.environment_type
+
+        out["type"] = capo_codebuild.types.environment_type.deserialize_aws_json_1_1(
+            data["type"]
+        )
+    else:
+        raise DeserializationError("ProjectEnvironment.type required")
+    if data.get("image") is not None:
+        out["image"] = data["image"]
+    else:
+        raise DeserializationError("ProjectEnvironment.image required")
+    if data.get("computeType") is not None:
+        import capo_codebuild.types.compute_type
+
+        out["compute_type"] = (
+            capo_codebuild.types.compute_type.deserialize_aws_json_1_1(
+                data["computeType"]
+            )
+        )
+    else:
+        raise DeserializationError("ProjectEnvironment.compute_type required")
+    if data.get("computeConfiguration") is not None:
+        import capo_codebuild.types.compute_configuration
+
+        out["compute_configuration"] = (
+            capo_codebuild.types.compute_configuration.deserialize_aws_json_1_1(
+                data["computeConfiguration"]
+            )
+        )
+    if data.get("fleet") is not None:
+        import capo_codebuild.types.project_fleet
+
+        out["fleet"] = capo_codebuild.types.project_fleet.deserialize_aws_json_1_1(
+            data["fleet"]
+        )
+    if data.get("environmentVariables") is not None:
+        import capo_codebuild.types.environment_variables
+
+        out["environment_variables"] = (
+            capo_codebuild.types.environment_variables.deserialize_aws_json_1_1(
+                data["environmentVariables"]
+            )
+        )
+    if data.get("privilegedMode") is not None:
+        out["privileged_mode"] = data["privilegedMode"]
+    if data.get("certificate") is not None:
+        out["certificate"] = data["certificate"]
+    if data.get("registryCredential") is not None:
+        import capo_codebuild.types.registry_credential
+
+        out["registry_credential"] = (
+            capo_codebuild.types.registry_credential.deserialize_aws_json_1_1(
+                data["registryCredential"]
+            )
+        )
+    if data.get("imagePullCredentialsType") is not None:
+        import capo_codebuild.types.image_pull_credentials_type
+
+        out["image_pull_credentials_type"] = (
+            capo_codebuild.types.image_pull_credentials_type.deserialize_aws_json_1_1(
+                data["imagePullCredentialsType"]
+            )
+        )
+    if data.get("dockerServer") is not None:
+        import capo_codebuild.types.docker_server
+
+        out["docker_server"] = (
+            capo_codebuild.types.docker_server.deserialize_aws_json_1_1(
+                data["dockerServer"]
+            )
+        )
+    return out

capo_codebuild/types/project_file_system_location.py

@@ -0,0 +1,61 @@
+"""Generated from Smithy shape ``com.amazonaws.codebuild#ProjectFileSystemLocation``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codebuild.types.file_system_type
+    import capo_codebuild.types.string
+
+
+class ProjectFileSystemLocation(TypedDict, closed=True):
+    type: NotRequired["capo_codebuild.types.file_system_type.FileSystemType"]
+    """<p> The type of the file system. The one supported type is <code>EFS</code>. </p>"""
+    location: NotRequired["capo_codebuild.types.string.String"]
+    """<p>A string that specifies the location of the file system created by Amazon EFS. Its format is <code>efs-dns-name:/directory-path</code>. You can find the DNS name of file system when you view it in the Amazon EFS console. The directory path is a path to a directory in the file system that CodeBuild mounts. For example, if the DNS name of a file system is <code>fs-abcd1234.efs.us-west-2.amazonaws.com</code>, and its mount directory is <code>my-efs-mount-directory</code>, then the <code>location</code> is <code>fs-abcd1234.efs.us-west-2.amazonaws.com:/my-efs-mount-directory</code>. </p> <p>The directory path in the format <code>efs-dns-name:/directory-path</code> is optional. If you do not specify a directory path, the location is only the DNS name and CodeBuild mounts the entire file system. </p>"""
+    mount_point: NotRequired["capo_codebuild.types.string.String"]
+    """<p>The location in the container where you mount the file system. </p>"""
+    identifier: NotRequired["capo_codebuild.types.string.String"]
+    """<p>The name used to access a file system created by Amazon EFS. CodeBuild creates an environment variable by appending the <code>identifier</code> in all capital letters to <code>CODEBUILD_</code>. For example, if you specify <code>my_efs</code> for <code>identifier</code>, a new environment variable is create named <code>CODEBUILD_MY_EFS</code>. </p> <p> The <code>identifier</code> is used to mount your file system. </p>"""
+    mount_options: NotRequired["capo_codebuild.types.string.String"]
+    r"""<p> The mount options for a file system created by Amazon EFS. The default mount options used by CodeBuild are <code>nfsvers=4.1,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2</code>. For more information, see <a href=\"https://docs.aws.amazon.com/efs/latest/ug/mounting-fs-nfs-mount-settings.html\">Recommended NFS Mount Options</a>. </p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ProjectFileSystemLocation) -> dict:
+    out: dict = {}
+    if "type" in value:
+        import capo_codebuild.types.file_system_type
+
+        out["type"] = capo_codebuild.types.file_system_type.serialize_aws_json_1_1(
+            value["type"]
+        )
+    if "location" in value:
+        out["location"] = value["location"]
+    if "mount_point" in value:
+        out["mountPoint"] = value["mount_point"]
+    if "identifier" in value:
+        out["identifier"] = value["identifier"]
+    if "mount_options" in value:
+        out["mountOptions"] = value["mount_options"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> ProjectFileSystemLocation:
+    out: ProjectFileSystemLocation = {}  # type: ignore[typeddict-item]
+    if data.get("type") is not None:
+        import capo_codebuild.types.file_system_type
+
+        out["type"] = capo_codebuild.types.file_system_type.deserialize_aws_json_1_1(
+            data["type"]
+        )
+    if data.get("location") is not None:
+        out["location"] = data["location"]
+    if data.get("mountPoint") is not None:
+        out["mount_point"] = data["mountPoint"]
+    if data.get("identifier") is not None:
+        out["identifier"] = data["identifier"]
+    if data.get("mountOptions") is not None:
+        out["mount_options"] = data["mountOptions"]
+    return out

capo_codebuild/types/project_file_system_locations.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.codebuild#ProjectFileSystemLocations``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codebuild.types.project_file_system_location
+
+ProjectFileSystemLocations: TypeAlias = list[
+    "capo_codebuild.types.project_file_system_location.ProjectFileSystemLocation"
+]
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ProjectFileSystemLocations) -> list:
+    import capo_codebuild.types.project_file_system_location
+
+    out: list = []
+    for item in value:
+        out.append(
+            capo_codebuild.types.project_file_system_location.serialize_aws_json_1_1(
+                item
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: list) -> ProjectFileSystemLocations:
+    import capo_codebuild.types.project_file_system_location
+
+    out: ProjectFileSystemLocations = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(
+            capo_codebuild.types.project_file_system_location.deserialize_aws_json_1_1(
+                item
+            )
+        )
+    return out

capo_codebuild/types/project_fleet.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.codebuild#ProjectFleet``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_codebuild.types.string
+
+
+class ProjectFleet(TypedDict, closed=True):
+    fleet_arn: NotRequired["capo_codebuild.types.string.String"]
+    """<p>Specifies the compute fleet ARN for the build project.</p>"""
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ProjectFleet) -> dict:
+    out: dict = {}
+    if "fleet_arn" in value:
+        out["fleetArn"] = value["fleet_arn"]
+    return out
+
+
+def deserialize_aws_json_1_1(data: dict) -> ProjectFleet:
+    out: ProjectFleet = {}  # type: ignore[typeddict-item]
+    if data.get("fleetArn") is not None:
+        out["fleet_arn"] = data["fleetArn"]
+    return out

capo_codebuild/types/project_name.py

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

capo_codebuild/types/project_names.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.codebuild#ProjectNames``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codebuild.types.non_empty_string
+
+ProjectNames: TypeAlias = list["capo_codebuild.types.non_empty_string.NonEmptyString"]
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ProjectNames) -> list:
+    return list(value)
+
+
+def deserialize_aws_json_1_1(data: list) -> ProjectNames:
+    return [item for item in data if item is not None]

capo_codebuild/types/project_secondary_source_versions.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.codebuild#ProjectSecondarySourceVersions``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_codebuild.types.project_source_version
+
+ProjectSecondarySourceVersions: TypeAlias = list[
+    "capo_codebuild.types.project_source_version.ProjectSourceVersion"
+]
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ProjectSecondarySourceVersions) -> list:
+    import capo_codebuild.types.project_source_version
+
+    out: list = []
+    for item in value:
+        out.append(
+            capo_codebuild.types.project_source_version.serialize_aws_json_1_1(item)
+        )
+    return out
+
+
+def deserialize_aws_json_1_1(data: list) -> ProjectSecondarySourceVersions:
+    import capo_codebuild.types.project_source_version
+
+    out: ProjectSecondarySourceVersions = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(
+            capo_codebuild.types.project_source_version.deserialize_aws_json_1_1(item)
+        )
+    return out

capo_codebuild/types/project_sort_by_type.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.codebuild#ProjectSortByType``."""
+
+from typing import Literal, TypeAlias, cast
+
+ProjectSortByType: TypeAlias = Literal[
+    "NAME",
+    "CREATED_TIME",
+    "LAST_MODIFIED_TIME",
+]
+
+
+# --- awsJson1_1 ser/de ---
+def serialize_aws_json_1_1(value: ProjectSortByType) -> str:
+    return value
+
+
+def deserialize_aws_json_1_1(data: str) -> ProjectSortByType:
+    return cast(ProjectSortByType, data)