pulumi-azure-native 2.76.0a1733162443__py3-none-any.whl → 2.76.0a1733488793__py3-none-any.whl

pulumi_azure_native/containerregistry/v20241101preview/outputs.py

@@ -0,0 +1,3171 @@
+# coding=utf-8
+# *** WARNING: this file was generated by pulumi-language-python. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import copy
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from ... import _utilities
+from . import outputs
+from ._enums import *
+
+__all__ = [
+    'ActivationPropertiesResponse',
+    'ActorResponse',
+    'ArchivePackageSourcePropertiesResponse',
+    'AuthCredentialResponse',
+    'AzureADAuthenticationAsArmPolicyResponse',
+    'CredentialHealthResponse',
+    'EncryptionPropertyResponse',
+    'EventContentResponse',
+    'EventRequestMessageResponse',
+    'EventResponse',
+    'EventResponseMessageResponse',
+    'ExportPipelineTargetPropertiesResponse',
+    'ExportPolicyResponse',
+    'GarbageCollectionPropertiesResponse',
+    'IPRuleResponse',
+    'IdentityPropertiesResponse',
+    'ImportPipelineSourcePropertiesResponse',
+    'KeyVaultPropertiesResponse',
+    'LoggingPropertiesResponse',
+    'LoginServerPropertiesResponse',
+    'NetworkRuleSetResponse',
+    'ParentPropertiesResponse',
+    'PipelineRunRequestResponse',
+    'PipelineRunResponseResponse',
+    'PipelineRunSourcePropertiesResponse',
+    'PipelineRunTargetPropertiesResponse',
+    'PipelineSourceTriggerDescriptorResponse',
+    'PipelineSourceTriggerPropertiesResponse',
+    'PipelineTriggerDescriptorResponse',
+    'PipelineTriggerPropertiesResponse',
+    'PoliciesResponse',
+    'PrivateEndpointConnectionResponse',
+    'PrivateEndpointResponse',
+    'PrivateLinkServiceConnectionStateResponse',
+    'ProgressPropertiesResponse',
+    'QuarantinePolicyResponse',
+    'RegistryPasswordResponse',
+    'RequestResponse',
+    'RetentionPolicyResponse',
+    'SkuResponse',
+    'SoftDeletePolicyResponse',
+    'SourceResponse',
+    'StatusDetailPropertiesResponse',
+    'StatusResponse',
+    'SyncPropertiesResponse',
+    'SystemDataResponse',
+    'TargetResponse',
+    'TlsCertificatePropertiesResponse',
+    'TlsPropertiesResponse',
+    'TokenCertificateResponse',
+    'TokenCredentialsPropertiesResponse',
+    'TokenPasswordResponse',
+    'TrustPolicyResponse',
+    'UserIdentityPropertiesResponse',
+]
+
+@pulumi.output_type
+class ActivationPropertiesResponse(dict):
+    """
+    The activation properties of the connected registry.
+    """
+    def __init__(__self__, *,
+                 status: str):
+        """
+        The activation properties of the connected registry.
+        :param str status: The activation status of the connected registry.
+        """
+        pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter
+    def status(self) -> str:
+        """
+        The activation status of the connected registry.
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class ActorResponse(dict):
+    """
+    The agent that initiated the event. For most situations, this could be from the authorization context of the request.
+    """
+    def __init__(__self__, *,
+                 name: Optional[str] = None):
+        """
+        The agent that initiated the event. For most situations, this could be from the authorization context of the request.
+        :param str name: The subject or username associated with the request context that generated the event.
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        The subject or username associated with the request context that generated the event.
+        """
+        return pulumi.get(self, "name")
+
+
+@pulumi.output_type
+class ArchivePackageSourcePropertiesResponse(dict):
+    """
+    The properties of the archive package source.
+    """
+    def __init__(__self__, *,
+                 type: Optional[str] = None,
+                 url: Optional[str] = None):
+        """
+        The properties of the archive package source.
+        :param str type: The type of package source for a archive.
+        :param str url: The external repository url.
+        """
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+        if url is not None:
+            pulumi.set(__self__, "url", url)
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        The type of package source for a archive.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter
+    def url(self) -> Optional[str]:
+        """
+        The external repository url.
+        """
+        return pulumi.get(self, "url")
+
+
+@pulumi.output_type
+class AuthCredentialResponse(dict):
+    """
+    Authentication credential stored for an upstream.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "credentialHealth":
+            suggest = "credential_health"
+        elif key == "passwordSecretIdentifier":
+            suggest = "password_secret_identifier"
+        elif key == "usernameSecretIdentifier":
+            suggest = "username_secret_identifier"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AuthCredentialResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AuthCredentialResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AuthCredentialResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 credential_health: 'outputs.CredentialHealthResponse',
+                 name: Optional[str] = None,
+                 password_secret_identifier: Optional[str] = None,
+                 username_secret_identifier: Optional[str] = None):
+        """
+        Authentication credential stored for an upstream.
+        :param 'CredentialHealthResponse' credential_health: This provides data pertaining to the health of the auth credential.
+        :param str name: The name of the credential.
+        :param str password_secret_identifier: KeyVault Secret URI for accessing the password.
+        :param str username_secret_identifier: KeyVault Secret URI for accessing the username.
+        """
+        pulumi.set(__self__, "credential_health", credential_health)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if password_secret_identifier is not None:
+            pulumi.set(__self__, "password_secret_identifier", password_secret_identifier)
+        if username_secret_identifier is not None:
+            pulumi.set(__self__, "username_secret_identifier", username_secret_identifier)
+
+    @property
+    @pulumi.getter(name="credentialHealth")
+    def credential_health(self) -> 'outputs.CredentialHealthResponse':
+        """
+        This provides data pertaining to the health of the auth credential.
+        """
+        return pulumi.get(self, "credential_health")
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        The name of the credential.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="passwordSecretIdentifier")
+    def password_secret_identifier(self) -> Optional[str]:
+        """
+        KeyVault Secret URI for accessing the password.
+        """
+        return pulumi.get(self, "password_secret_identifier")
+
+    @property
+    @pulumi.getter(name="usernameSecretIdentifier")
+    def username_secret_identifier(self) -> Optional[str]:
+        """
+        KeyVault Secret URI for accessing the username.
+        """
+        return pulumi.get(self, "username_secret_identifier")
+
+
+@pulumi.output_type
+class AzureADAuthenticationAsArmPolicyResponse(dict):
+    """
+    The policy for using ARM audience token for a container registry.
+    """
+    def __init__(__self__, *,
+                 status: Optional[str] = None):
+        """
+        The policy for using ARM audience token for a container registry.
+        :param str status: The value that indicates whether the policy is enabled or not.
+        """
+        if status is None:
+            status = 'enabled'
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[str]:
+        """
+        The value that indicates whether the policy is enabled or not.
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class CredentialHealthResponse(dict):
+    """
+    The health of the auth credential.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "errorCode":
+            suggest = "error_code"
+        elif key == "errorMessage":
+            suggest = "error_message"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CredentialHealthResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CredentialHealthResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CredentialHealthResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 error_code: Optional[str] = None,
+                 error_message: Optional[str] = None,
+                 status: Optional[str] = None):
+        """
+        The health of the auth credential.
+        :param str error_code: Error code representing the health check error.
+        :param str error_message: Descriptive message representing the health check error.
+        :param str status: The health status of credential.
+        """
+        if error_code is not None:
+            pulumi.set(__self__, "error_code", error_code)
+        if error_message is not None:
+            pulumi.set(__self__, "error_message", error_message)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter(name="errorCode")
+    def error_code(self) -> Optional[str]:
+        """
+        Error code representing the health check error.
+        """
+        return pulumi.get(self, "error_code")
+
+    @property
+    @pulumi.getter(name="errorMessage")
+    def error_message(self) -> Optional[str]:
+        """
+        Descriptive message representing the health check error.
+        """
+        return pulumi.get(self, "error_message")
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[str]:
+        """
+        The health status of credential.
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class EncryptionPropertyResponse(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "keyVaultProperties":
+            suggest = "key_vault_properties"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in EncryptionPropertyResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        EncryptionPropertyResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        EncryptionPropertyResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 key_vault_properties: Optional['outputs.KeyVaultPropertiesResponse'] = None,
+                 status: Optional[str] = None):
+        """
+        :param 'KeyVaultPropertiesResponse' key_vault_properties: Key vault properties.
+        :param str status: Indicates whether or not the encryption is enabled for container registry.
+        """
+        if key_vault_properties is not None:
+            pulumi.set(__self__, "key_vault_properties", key_vault_properties)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter(name="keyVaultProperties")
+    def key_vault_properties(self) -> Optional['outputs.KeyVaultPropertiesResponse']:
+        """
+        Key vault properties.
+        """
+        return pulumi.get(self, "key_vault_properties")
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[str]:
+        """
+        Indicates whether or not the encryption is enabled for container registry.
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class EventContentResponse(dict):
+    """
+    The content of the event request message.
+    """
+    def __init__(__self__, *,
+                 action: Optional[str] = None,
+                 actor: Optional['outputs.ActorResponse'] = None,
+                 id: Optional[str] = None,
+                 request: Optional['outputs.RequestResponse'] = None,
+                 source: Optional['outputs.SourceResponse'] = None,
+                 target: Optional['outputs.TargetResponse'] = None,
+                 timestamp: Optional[str] = None):
+        """
+        The content of the event request message.
+        :param str action: The action that encompasses the provided event.
+        :param 'ActorResponse' actor: The agent that initiated the event. For most situations, this could be from the authorization context of the request.
+        :param str id: The event ID.
+        :param 'RequestResponse' request: The request that generated the event.
+        :param 'SourceResponse' source: The registry node that generated the event. Put differently, while the actor initiates the event, the source generates it.
+        :param 'TargetResponse' target: The target of the event.
+        :param str timestamp: The time at which the event occurred.
+        """
+        if action is not None:
+            pulumi.set(__self__, "action", action)
+        if actor is not None:
+            pulumi.set(__self__, "actor", actor)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if request is not None:
+            pulumi.set(__self__, "request", request)
+        if source is not None:
+            pulumi.set(__self__, "source", source)
+        if target is not None:
+            pulumi.set(__self__, "target", target)
+        if timestamp is not None:
+            pulumi.set(__self__, "timestamp", timestamp)
+
+    @property
+    @pulumi.getter
+    def action(self) -> Optional[str]:
+        """
+        The action that encompasses the provided event.
+        """
+        return pulumi.get(self, "action")
+
+    @property
+    @pulumi.getter
+    def actor(self) -> Optional['outputs.ActorResponse']:
+        """
+        The agent that initiated the event. For most situations, this could be from the authorization context of the request.
+        """
+        return pulumi.get(self, "actor")
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[str]:
+        """
+        The event ID.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def request(self) -> Optional['outputs.RequestResponse']:
+        """
+        The request that generated the event.
+        """
+        return pulumi.get(self, "request")
+
+    @property
+    @pulumi.getter
+    def source(self) -> Optional['outputs.SourceResponse']:
+        """
+        The registry node that generated the event. Put differently, while the actor initiates the event, the source generates it.
+        """
+        return pulumi.get(self, "source")
+
+    @property
+    @pulumi.getter
+    def target(self) -> Optional['outputs.TargetResponse']:
+        """
+        The target of the event.
+        """
+        return pulumi.get(self, "target")
+
+    @property
+    @pulumi.getter
+    def timestamp(self) -> Optional[str]:
+        """
+        The time at which the event occurred.
+        """
+        return pulumi.get(self, "timestamp")
+
+
+@pulumi.output_type
+class EventRequestMessageResponse(dict):
+    """
+    The event request message sent to the service URI.
+    """
+    def __init__(__self__, *,
+                 content: Optional['outputs.EventContentResponse'] = None,
+                 headers: Optional[Mapping[str, str]] = None,
+                 method: Optional[str] = None,
+                 request_uri: Optional[str] = None,
+                 version: Optional[str] = None):
+        """
+        The event request message sent to the service URI.
+        :param 'EventContentResponse' content: The content of the event request message.
+        :param Mapping[str, str] headers: The headers of the event request message.
+        :param str method: The HTTP method used to send the event request message.
+        :param str request_uri: The URI used to send the event request message.
+        :param str version: The HTTP message version.
+        """
+        if content is not None:
+            pulumi.set(__self__, "content", content)
+        if headers is not None:
+            pulumi.set(__self__, "headers", headers)
+        if method is not None:
+            pulumi.set(__self__, "method", method)
+        if request_uri is not None:
+            pulumi.set(__self__, "request_uri", request_uri)
+        if version is not None:
+            pulumi.set(__self__, "version", version)
+
+    @property
+    @pulumi.getter
+    def content(self) -> Optional['outputs.EventContentResponse']:
+        """
+        The content of the event request message.
+        """
+        return pulumi.get(self, "content")
+
+    @property
+    @pulumi.getter
+    def headers(self) -> Optional[Mapping[str, str]]:
+        """
+        The headers of the event request message.
+        """
+        return pulumi.get(self, "headers")
+
+    @property
+    @pulumi.getter
+    def method(self) -> Optional[str]:
+        """
+        The HTTP method used to send the event request message.
+        """
+        return pulumi.get(self, "method")
+
+    @property
+    @pulumi.getter(name="requestUri")
+    def request_uri(self) -> Optional[str]:
+        """
+        The URI used to send the event request message.
+        """
+        return pulumi.get(self, "request_uri")
+
+    @property
+    @pulumi.getter
+    def version(self) -> Optional[str]:
+        """
+        The HTTP message version.
+        """
+        return pulumi.get(self, "version")
+
+
+@pulumi.output_type
+class EventResponse(dict):
+    """
+    The event for a webhook.
+    """
+    def __init__(__self__, *,
+                 event_request_message: Optional['outputs.EventRequestMessageResponse'] = None,
+                 event_response_message: Optional['outputs.EventResponseMessageResponse'] = None,
+                 id: Optional[str] = None):
+        """
+        The event for a webhook.
+        :param 'EventRequestMessageResponse' event_request_message: The event request message sent to the service URI.
+        :param 'EventResponseMessageResponse' event_response_message: The event response message received from the service URI.
+        :param str id: The event ID.
+        """
+        if event_request_message is not None:
+            pulumi.set(__self__, "event_request_message", event_request_message)
+        if event_response_message is not None:
+            pulumi.set(__self__, "event_response_message", event_response_message)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+
+    @property
+    @pulumi.getter(name="eventRequestMessage")
+    def event_request_message(self) -> Optional['outputs.EventRequestMessageResponse']:
+        """
+        The event request message sent to the service URI.
+        """
+        return pulumi.get(self, "event_request_message")
+
+    @property
+    @pulumi.getter(name="eventResponseMessage")
+    def event_response_message(self) -> Optional['outputs.EventResponseMessageResponse']:
+        """
+        The event response message received from the service URI.
+        """
+        return pulumi.get(self, "event_response_message")
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[str]:
+        """
+        The event ID.
+        """
+        return pulumi.get(self, "id")
+
+
+@pulumi.output_type
+class EventResponseMessageResponse(dict):
+    """
+    The event response message received from the service URI.
+    """
+    def __init__(__self__, *,
+                 content: Optional[str] = None,
+                 headers: Optional[Mapping[str, str]] = None,
+                 reason_phrase: Optional[str] = None,
+                 status_code: Optional[str] = None,
+                 version: Optional[str] = None):
+        """
+        The event response message received from the service URI.
+        :param str content: The content of the event response message.
+        :param Mapping[str, str] headers: The headers of the event response message.
+        :param str reason_phrase: The reason phrase of the event response message.
+        :param str status_code: The status code of the event response message.
+        :param str version: The HTTP message version.
+        """
+        if content is not None:
+            pulumi.set(__self__, "content", content)
+        if headers is not None:
+            pulumi.set(__self__, "headers", headers)
+        if reason_phrase is not None:
+            pulumi.set(__self__, "reason_phrase", reason_phrase)
+        if status_code is not None:
+            pulumi.set(__self__, "status_code", status_code)
+        if version is not None:
+            pulumi.set(__self__, "version", version)
+
+    @property
+    @pulumi.getter
+    def content(self) -> Optional[str]:
+        """
+        The content of the event response message.
+        """
+        return pulumi.get(self, "content")
+
+    @property
+    @pulumi.getter
+    def headers(self) -> Optional[Mapping[str, str]]:
+        """
+        The headers of the event response message.
+        """
+        return pulumi.get(self, "headers")
+
+    @property
+    @pulumi.getter(name="reasonPhrase")
+    def reason_phrase(self) -> Optional[str]:
+        """
+        The reason phrase of the event response message.
+        """
+        return pulumi.get(self, "reason_phrase")
+
+    @property
+    @pulumi.getter(name="statusCode")
+    def status_code(self) -> Optional[str]:
+        """
+        The status code of the event response message.
+        """
+        return pulumi.get(self, "status_code")
+
+    @property
+    @pulumi.getter
+    def version(self) -> Optional[str]:
+        """
+        The HTTP message version.
+        """
+        return pulumi.get(self, "version")
+
+
+@pulumi.output_type
+class ExportPipelineTargetPropertiesResponse(dict):
+    """
+    The properties of the export pipeline target.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "keyVaultUri":
+            suggest = "key_vault_uri"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ExportPipelineTargetPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ExportPipelineTargetPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ExportPipelineTargetPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 key_vault_uri: str,
+                 type: Optional[str] = None,
+                 uri: Optional[str] = None):
+        """
+        The properties of the export pipeline target.
+        :param str key_vault_uri: They key vault secret uri to obtain the target storage SAS token.
+        :param str type: The type of target for the export pipeline.
+        :param str uri: The target uri of the export pipeline.
+               When 'AzureStorageBlob': "https://accountName.blob.core.windows.net/containerName/blobName"
+               When 'AzureStorageBlobContainer':  "https://accountName.blob.core.windows.net/containerName"
+        """
+        pulumi.set(__self__, "key_vault_uri", key_vault_uri)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+        if uri is not None:
+            pulumi.set(__self__, "uri", uri)
+
+    @property
+    @pulumi.getter(name="keyVaultUri")
+    def key_vault_uri(self) -> str:
+        """
+        They key vault secret uri to obtain the target storage SAS token.
+        """
+        return pulumi.get(self, "key_vault_uri")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        The type of target for the export pipeline.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter
+    def uri(self) -> Optional[str]:
+        """
+        The target uri of the export pipeline.
+        When 'AzureStorageBlob': "https://accountName.blob.core.windows.net/containerName/blobName"
+        When 'AzureStorageBlobContainer':  "https://accountName.blob.core.windows.net/containerName"
+        """
+        return pulumi.get(self, "uri")
+
+
+@pulumi.output_type
+class ExportPolicyResponse(dict):
+    """
+    The export policy for a container registry.
+    """
+    def __init__(__self__, *,
+                 status: Optional[str] = None):
+        """
+        The export policy for a container registry.
+        :param str status: The value that indicates whether the policy is enabled or not.
+        """
+        if status is None:
+            status = 'enabled'
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[str]:
+        """
+        The value that indicates whether the policy is enabled or not.
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class GarbageCollectionPropertiesResponse(dict):
+    """
+    The garbage collection properties of the connected registry.
+    """
+    def __init__(__self__, *,
+                 enabled: Optional[bool] = None,
+                 schedule: Optional[str] = None):
+        """
+        The garbage collection properties of the connected registry.
+        :param bool enabled: Indicates whether garbage collection is enabled for the connected registry.
+        :param str schedule: The cron expression indicating the schedule that the connected registry will run garbage collection.
+        """
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+        if schedule is not None:
+            pulumi.set(__self__, "schedule", schedule)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[bool]:
+        """
+        Indicates whether garbage collection is enabled for the connected registry.
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter
+    def schedule(self) -> Optional[str]:
+        """
+        The cron expression indicating the schedule that the connected registry will run garbage collection.
+        """
+        return pulumi.get(self, "schedule")
+
+
+@pulumi.output_type
+class IPRuleResponse(dict):
+    """
+    IP rule with specific IP or IP range in CIDR format.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "iPAddressOrRange":
+            suggest = "i_p_address_or_range"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in IPRuleResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        IPRuleResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        IPRuleResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 i_p_address_or_range: str,
+                 action: Optional[str] = None):
+        """
+        IP rule with specific IP or IP range in CIDR format.
+        :param str i_p_address_or_range: Specifies the IP or IP range in CIDR format. Only IPV4 address is allowed.
+        :param str action: The action of IP ACL rule.
+        """
+        pulumi.set(__self__, "i_p_address_or_range", i_p_address_or_range)
+        if action is None:
+            action = 'Allow'
+        if action is not None:
+            pulumi.set(__self__, "action", action)
+
+    @property
+    @pulumi.getter(name="iPAddressOrRange")
+    def i_p_address_or_range(self) -> str:
+        """
+        Specifies the IP or IP range in CIDR format. Only IPV4 address is allowed.
+        """
+        return pulumi.get(self, "i_p_address_or_range")
+
+    @property
+    @pulumi.getter
+    def action(self) -> Optional[str]:
+        """
+        The action of IP ACL rule.
+        """
+        return pulumi.get(self, "action")
+
+
+@pulumi.output_type
+class IdentityPropertiesResponse(dict):
+    """
+    Managed identity for the resource.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "principalId":
+            suggest = "principal_id"
+        elif key == "tenantId":
+            suggest = "tenant_id"
+        elif key == "userAssignedIdentities":
+            suggest = "user_assigned_identities"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in IdentityPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        IdentityPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        IdentityPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 principal_id: str,
+                 tenant_id: str,
+                 type: Optional[str] = None,
+                 user_assigned_identities: Optional[Mapping[str, 'outputs.UserIdentityPropertiesResponse']] = None):
+        """
+        Managed identity for the resource.
+        :param str principal_id: The principal ID of resource identity.
+        :param str tenant_id: The tenant ID of resource.
+        :param str type: The identity type.
+        :param Mapping[str, 'UserIdentityPropertiesResponse'] user_assigned_identities: The list of user identities associated with the resource. The user identity 
+               dictionary key references will be ARM resource ids in the form: 
+               '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/
+                   providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
+        """
+        pulumi.set(__self__, "principal_id", principal_id)
+        pulumi.set(__self__, "tenant_id", tenant_id)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+        if user_assigned_identities is not None:
+            pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
+
+    @property
+    @pulumi.getter(name="principalId")
+    def principal_id(self) -> str:
+        """
+        The principal ID of resource identity.
+        """
+        return pulumi.get(self, "principal_id")
+
+    @property
+    @pulumi.getter(name="tenantId")
+    def tenant_id(self) -> str:
+        """
+        The tenant ID of resource.
+        """
+        return pulumi.get(self, "tenant_id")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        The identity type.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="userAssignedIdentities")
+    def user_assigned_identities(self) -> Optional[Mapping[str, 'outputs.UserIdentityPropertiesResponse']]:
+        """
+        The list of user identities associated with the resource. The user identity 
+        dictionary key references will be ARM resource ids in the form: 
+        '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/
+            providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
+        """
+        return pulumi.get(self, "user_assigned_identities")
+
+
+@pulumi.output_type
+class ImportPipelineSourcePropertiesResponse(dict):
+    """
+    The properties of the import pipeline source.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "keyVaultUri":
+            suggest = "key_vault_uri"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ImportPipelineSourcePropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ImportPipelineSourcePropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ImportPipelineSourcePropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 key_vault_uri: str,
+                 type: Optional[str] = None,
+                 uri: Optional[str] = None):
+        """
+        The properties of the import pipeline source.
+        :param str key_vault_uri: They key vault secret uri to obtain the source storage SAS token.
+        :param str type: The type of source for the import pipeline.
+        :param str uri: The source uri of the import pipeline.
+               When 'AzureStorageBlob': "https://accountName.blob.core.windows.net/containerName/blobName"
+               When 'AzureStorageBlobContainer': "https://accountName.blob.core.windows.net/containerName"
+        """
+        pulumi.set(__self__, "key_vault_uri", key_vault_uri)
+        if type is None:
+            type = 'AzureStorageBlobContainer'
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+        if uri is not None:
+            pulumi.set(__self__, "uri", uri)
+
+    @property
+    @pulumi.getter(name="keyVaultUri")
+    def key_vault_uri(self) -> str:
+        """
+        They key vault secret uri to obtain the source storage SAS token.
+        """
+        return pulumi.get(self, "key_vault_uri")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        The type of source for the import pipeline.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter
+    def uri(self) -> Optional[str]:
+        """
+        The source uri of the import pipeline.
+        When 'AzureStorageBlob': "https://accountName.blob.core.windows.net/containerName/blobName"
+        When 'AzureStorageBlobContainer': "https://accountName.blob.core.windows.net/containerName"
+        """
+        return pulumi.get(self, "uri")
+
+
+@pulumi.output_type
+class KeyVaultPropertiesResponse(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "keyRotationEnabled":
+            suggest = "key_rotation_enabled"
+        elif key == "lastKeyRotationTimestamp":
+            suggest = "last_key_rotation_timestamp"
+        elif key == "versionedKeyIdentifier":
+            suggest = "versioned_key_identifier"
+        elif key == "keyIdentifier":
+            suggest = "key_identifier"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in KeyVaultPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        KeyVaultPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        KeyVaultPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 key_rotation_enabled: bool,
+                 last_key_rotation_timestamp: str,
+                 versioned_key_identifier: str,
+                 identity: Optional[str] = None,
+                 key_identifier: Optional[str] = None):
+        """
+        :param bool key_rotation_enabled: Auto key rotation status for a CMK enabled registry.
+        :param str last_key_rotation_timestamp: Timestamp of the last successful key rotation.
+        :param str versioned_key_identifier: The fully qualified key identifier that includes the version of the key that is actually used for encryption.
+        :param str identity: The client id of the identity which will be used to access key vault.
+        :param str key_identifier: Key vault uri to access the encryption key.
+        """
+        pulumi.set(__self__, "key_rotation_enabled", key_rotation_enabled)
+        pulumi.set(__self__, "last_key_rotation_timestamp", last_key_rotation_timestamp)
+        pulumi.set(__self__, "versioned_key_identifier", versioned_key_identifier)
+        if identity is not None:
+            pulumi.set(__self__, "identity", identity)
+        if key_identifier is not None:
+            pulumi.set(__self__, "key_identifier", key_identifier)
+
+    @property
+    @pulumi.getter(name="keyRotationEnabled")
+    def key_rotation_enabled(self) -> bool:
+        """
+        Auto key rotation status for a CMK enabled registry.
+        """
+        return pulumi.get(self, "key_rotation_enabled")
+
+    @property
+    @pulumi.getter(name="lastKeyRotationTimestamp")
+    def last_key_rotation_timestamp(self) -> str:
+        """
+        Timestamp of the last successful key rotation.
+        """
+        return pulumi.get(self, "last_key_rotation_timestamp")
+
+    @property
+    @pulumi.getter(name="versionedKeyIdentifier")
+    def versioned_key_identifier(self) -> str:
+        """
+        The fully qualified key identifier that includes the version of the key that is actually used for encryption.
+        """
+        return pulumi.get(self, "versioned_key_identifier")
+
+    @property
+    @pulumi.getter
+    def identity(self) -> Optional[str]:
+        """
+        The client id of the identity which will be used to access key vault.
+        """
+        return pulumi.get(self, "identity")
+
+    @property
+    @pulumi.getter(name="keyIdentifier")
+    def key_identifier(self) -> Optional[str]:
+        """
+        Key vault uri to access the encryption key.
+        """
+        return pulumi.get(self, "key_identifier")
+
+
+@pulumi.output_type
+class LoggingPropertiesResponse(dict):
+    """
+    The logging properties of the connected registry.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "auditLogStatus":
+            suggest = "audit_log_status"
+        elif key == "logLevel":
+            suggest = "log_level"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in LoggingPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        LoggingPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        LoggingPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 audit_log_status: Optional[str] = None,
+                 log_level: Optional[str] = None):
+        """
+        The logging properties of the connected registry.
+        :param str audit_log_status: Indicates whether audit logs are enabled on the connected registry.
+        :param str log_level: The verbosity of logs persisted on the connected registry.
+        """
+        if audit_log_status is None:
+            audit_log_status = 'Disabled'
+        if audit_log_status is not None:
+            pulumi.set(__self__, "audit_log_status", audit_log_status)
+        if log_level is None:
+            log_level = 'Information'
+        if log_level is not None:
+            pulumi.set(__self__, "log_level", log_level)
+
+    @property
+    @pulumi.getter(name="auditLogStatus")
+    def audit_log_status(self) -> Optional[str]:
+        """
+        Indicates whether audit logs are enabled on the connected registry.
+        """
+        return pulumi.get(self, "audit_log_status")
+
+    @property
+    @pulumi.getter(name="logLevel")
+    def log_level(self) -> Optional[str]:
+        """
+        The verbosity of logs persisted on the connected registry.
+        """
+        return pulumi.get(self, "log_level")
+
+
+@pulumi.output_type
+class LoginServerPropertiesResponse(dict):
+    """
+    The login server properties of the connected registry.
+    """
+    def __init__(__self__, *,
+                 host: str,
+                 tls: 'outputs.TlsPropertiesResponse'):
+        """
+        The login server properties of the connected registry.
+        :param str host: The host of the connected registry. Can be FQDN or IP.
+        :param 'TlsPropertiesResponse' tls: The TLS properties of the connected registry login server.
+        """
+        pulumi.set(__self__, "host", host)
+        pulumi.set(__self__, "tls", tls)
+
+    @property
+    @pulumi.getter
+    def host(self) -> str:
+        """
+        The host of the connected registry. Can be FQDN or IP.
+        """
+        return pulumi.get(self, "host")
+
+    @property
+    @pulumi.getter
+    def tls(self) -> 'outputs.TlsPropertiesResponse':
+        """
+        The TLS properties of the connected registry login server.
+        """
+        return pulumi.get(self, "tls")
+
+
+@pulumi.output_type
+class NetworkRuleSetResponse(dict):
+    """
+    The network rule set for a container registry.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "defaultAction":
+            suggest = "default_action"
+        elif key == "ipRules":
+            suggest = "ip_rules"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NetworkRuleSetResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NetworkRuleSetResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NetworkRuleSetResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 default_action: Optional[str] = None,
+                 ip_rules: Optional[Sequence['outputs.IPRuleResponse']] = None):
+        """
+        The network rule set for a container registry.
+        :param str default_action: The default action of allow or deny when no other rules match.
+        :param Sequence['IPRuleResponse'] ip_rules: The IP ACL rules.
+        """
+        if default_action is None:
+            default_action = 'Allow'
+        pulumi.set(__self__, "default_action", default_action)
+        if ip_rules is not None:
+            pulumi.set(__self__, "ip_rules", ip_rules)
+
+    @property
+    @pulumi.getter(name="defaultAction")
+    def default_action(self) -> str:
+        """
+        The default action of allow or deny when no other rules match.
+        """
+        return pulumi.get(self, "default_action")
+
+    @property
+    @pulumi.getter(name="ipRules")
+    def ip_rules(self) -> Optional[Sequence['outputs.IPRuleResponse']]:
+        """
+        The IP ACL rules.
+        """
+        return pulumi.get(self, "ip_rules")
+
+
+@pulumi.output_type
+class ParentPropertiesResponse(dict):
+    """
+    The properties of the connected registry parent.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "syncProperties":
+            suggest = "sync_properties"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ParentPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ParentPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ParentPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 sync_properties: 'outputs.SyncPropertiesResponse',
+                 id: Optional[str] = None):
+        """
+        The properties of the connected registry parent.
+        :param 'SyncPropertiesResponse' sync_properties: The sync properties of the connected registry with its parent.
+        :param str id: The resource ID of the parent to which the connected registry will be associated.
+        """
+        pulumi.set(__self__, "sync_properties", sync_properties)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+
+    @property
+    @pulumi.getter(name="syncProperties")
+    def sync_properties(self) -> 'outputs.SyncPropertiesResponse':
+        """
+        The sync properties of the connected registry with its parent.
+        """
+        return pulumi.get(self, "sync_properties")
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[str]:
+        """
+        The resource ID of the parent to which the connected registry will be associated.
+        """
+        return pulumi.get(self, "id")
+
+
+@pulumi.output_type
+class PipelineRunRequestResponse(dict):
+    """
+    The request properties provided for a pipeline run.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "catalogDigest":
+            suggest = "catalog_digest"
+        elif key == "pipelineResourceId":
+            suggest = "pipeline_resource_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PipelineRunRequestResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PipelineRunRequestResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PipelineRunRequestResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 artifacts: Optional[Sequence[str]] = None,
+                 catalog_digest: Optional[str] = None,
+                 pipeline_resource_id: Optional[str] = None,
+                 source: Optional['outputs.PipelineRunSourcePropertiesResponse'] = None,
+                 target: Optional['outputs.PipelineRunTargetPropertiesResponse'] = None):
+        """
+        The request properties provided for a pipeline run.
+        :param Sequence[str] artifacts: List of source artifacts to be transferred by the pipeline. 
+               Specify an image by repository ('hello-world'). This will use the 'latest' tag.
+               Specify an image by tag ('hello-world:latest').
+               Specify an image by sha256-based manifest digest ('hello-world@sha256:abc123').
+        :param str catalog_digest: The digest of the tar used to transfer the artifacts.
+        :param str pipeline_resource_id: The resource ID of the pipeline to run.
+        :param 'PipelineRunSourcePropertiesResponse' source: The source properties of the pipeline run.
+        :param 'PipelineRunTargetPropertiesResponse' target: The target properties of the pipeline run.
+        """
+        if artifacts is not None:
+            pulumi.set(__self__, "artifacts", artifacts)
+        if catalog_digest is not None:
+            pulumi.set(__self__, "catalog_digest", catalog_digest)
+        if pipeline_resource_id is not None:
+            pulumi.set(__self__, "pipeline_resource_id", pipeline_resource_id)
+        if source is not None:
+            pulumi.set(__self__, "source", source)
+        if target is not None:
+            pulumi.set(__self__, "target", target)
+
+    @property
+    @pulumi.getter
+    def artifacts(self) -> Optional[Sequence[str]]:
+        """
+        List of source artifacts to be transferred by the pipeline. 
+        Specify an image by repository ('hello-world'). This will use the 'latest' tag.
+        Specify an image by tag ('hello-world:latest').
+        Specify an image by sha256-based manifest digest ('hello-world@sha256:abc123').
+        """
+        return pulumi.get(self, "artifacts")
+
+    @property
+    @pulumi.getter(name="catalogDigest")
+    def catalog_digest(self) -> Optional[str]:
+        """
+        The digest of the tar used to transfer the artifacts.
+        """
+        return pulumi.get(self, "catalog_digest")
+
+    @property
+    @pulumi.getter(name="pipelineResourceId")
+    def pipeline_resource_id(self) -> Optional[str]:
+        """
+        The resource ID of the pipeline to run.
+        """
+        return pulumi.get(self, "pipeline_resource_id")
+
+    @property
+    @pulumi.getter
+    def source(self) -> Optional['outputs.PipelineRunSourcePropertiesResponse']:
+        """
+        The source properties of the pipeline run.
+        """
+        return pulumi.get(self, "source")
+
+    @property
+    @pulumi.getter
+    def target(self) -> Optional['outputs.PipelineRunTargetPropertiesResponse']:
+        """
+        The target properties of the pipeline run.
+        """
+        return pulumi.get(self, "target")
+
+
+@pulumi.output_type
+class PipelineRunResponseResponse(dict):
+    """
+    The response properties returned for a pipeline run.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "catalogDigest":
+            suggest = "catalog_digest"
+        elif key == "finishTime":
+            suggest = "finish_time"
+        elif key == "importedArtifacts":
+            suggest = "imported_artifacts"
+        elif key == "pipelineRunErrorMessage":
+            suggest = "pipeline_run_error_message"
+        elif key == "startTime":
+            suggest = "start_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PipelineRunResponseResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PipelineRunResponseResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PipelineRunResponseResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 catalog_digest: Optional[str] = None,
+                 finish_time: Optional[str] = None,
+                 imported_artifacts: Optional[Sequence[str]] = None,
+                 pipeline_run_error_message: Optional[str] = None,
+                 progress: Optional['outputs.ProgressPropertiesResponse'] = None,
+                 source: Optional['outputs.ImportPipelineSourcePropertiesResponse'] = None,
+                 start_time: Optional[str] = None,
+                 status: Optional[str] = None,
+                 target: Optional['outputs.ExportPipelineTargetPropertiesResponse'] = None,
+                 trigger: Optional['outputs.PipelineTriggerDescriptorResponse'] = None):
+        """
+        The response properties returned for a pipeline run.
+        :param str catalog_digest: The digest of the tar used to transfer the artifacts.
+        :param str finish_time: The time the pipeline run finished.
+        :param Sequence[str] imported_artifacts: The artifacts imported in the pipeline run.
+        :param str pipeline_run_error_message: The detailed error message for the pipeline run in the case of failure.
+        :param 'ProgressPropertiesResponse' progress: The current progress of the copy operation.
+        :param 'ImportPipelineSourcePropertiesResponse' source: The source of the pipeline run.
+        :param str start_time: The time the pipeline run started.
+        :param str status: The current status of the pipeline run.
+        :param 'ExportPipelineTargetPropertiesResponse' target: The target of the pipeline run.
+        :param 'PipelineTriggerDescriptorResponse' trigger: The trigger that caused the pipeline run.
+        """
+        if catalog_digest is not None:
+            pulumi.set(__self__, "catalog_digest", catalog_digest)
+        if finish_time is not None:
+            pulumi.set(__self__, "finish_time", finish_time)
+        if imported_artifacts is not None:
+            pulumi.set(__self__, "imported_artifacts", imported_artifacts)
+        if pipeline_run_error_message is not None:
+            pulumi.set(__self__, "pipeline_run_error_message", pipeline_run_error_message)
+        if progress is not None:
+            pulumi.set(__self__, "progress", progress)
+        if source is not None:
+            pulumi.set(__self__, "source", source)
+        if start_time is not None:
+            pulumi.set(__self__, "start_time", start_time)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+        if target is not None:
+            pulumi.set(__self__, "target", target)
+        if trigger is not None:
+            pulumi.set(__self__, "trigger", trigger)
+
+    @property
+    @pulumi.getter(name="catalogDigest")
+    def catalog_digest(self) -> Optional[str]:
+        """
+        The digest of the tar used to transfer the artifacts.
+        """
+        return pulumi.get(self, "catalog_digest")
+
+    @property
+    @pulumi.getter(name="finishTime")
+    def finish_time(self) -> Optional[str]:
+        """
+        The time the pipeline run finished.
+        """
+        return pulumi.get(self, "finish_time")
+
+    @property
+    @pulumi.getter(name="importedArtifacts")
+    def imported_artifacts(self) -> Optional[Sequence[str]]:
+        """
+        The artifacts imported in the pipeline run.
+        """
+        return pulumi.get(self, "imported_artifacts")
+
+    @property
+    @pulumi.getter(name="pipelineRunErrorMessage")
+    def pipeline_run_error_message(self) -> Optional[str]:
+        """
+        The detailed error message for the pipeline run in the case of failure.
+        """
+        return pulumi.get(self, "pipeline_run_error_message")
+
+    @property
+    @pulumi.getter
+    def progress(self) -> Optional['outputs.ProgressPropertiesResponse']:
+        """
+        The current progress of the copy operation.
+        """
+        return pulumi.get(self, "progress")
+
+    @property
+    @pulumi.getter
+    def source(self) -> Optional['outputs.ImportPipelineSourcePropertiesResponse']:
+        """
+        The source of the pipeline run.
+        """
+        return pulumi.get(self, "source")
+
+    @property
+    @pulumi.getter(name="startTime")
+    def start_time(self) -> Optional[str]:
+        """
+        The time the pipeline run started.
+        """
+        return pulumi.get(self, "start_time")
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[str]:
+        """
+        The current status of the pipeline run.
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter
+    def target(self) -> Optional['outputs.ExportPipelineTargetPropertiesResponse']:
+        """
+        The target of the pipeline run.
+        """
+        return pulumi.get(self, "target")
+
+    @property
+    @pulumi.getter
+    def trigger(self) -> Optional['outputs.PipelineTriggerDescriptorResponse']:
+        """
+        The trigger that caused the pipeline run.
+        """
+        return pulumi.get(self, "trigger")
+
+
+@pulumi.output_type
+class PipelineRunSourcePropertiesResponse(dict):
+    def __init__(__self__, *,
+                 name: Optional[str] = None,
+                 type: Optional[str] = None):
+        """
+        :param str name: The name of the source.
+        :param str type: The type of the source.
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if type is None:
+            type = 'AzureStorageBlob'
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        The name of the source.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        The type of the source.
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class PipelineRunTargetPropertiesResponse(dict):
+    def __init__(__self__, *,
+                 name: Optional[str] = None,
+                 type: Optional[str] = None):
+        """
+        :param str name: The name of the target.
+        :param str type: The type of the target.
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if type is None:
+            type = 'AzureStorageBlob'
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        The name of the target.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        The type of the target.
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class PipelineSourceTriggerDescriptorResponse(dict):
+    def __init__(__self__, *,
+                 timestamp: Optional[str] = None):
+        """
+        :param str timestamp: The timestamp when the source update happened.
+        """
+        if timestamp is not None:
+            pulumi.set(__self__, "timestamp", timestamp)
+
+    @property
+    @pulumi.getter
+    def timestamp(self) -> Optional[str]:
+        """
+        The timestamp when the source update happened.
+        """
+        return pulumi.get(self, "timestamp")
+
+
+@pulumi.output_type
+class PipelineSourceTriggerPropertiesResponse(dict):
+    def __init__(__self__, *,
+                 status: Optional[str] = None):
+        """
+        :param str status: The current status of the source trigger.
+        """
+        if status is None:
+            status = 'Enabled'
+        pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter
+    def status(self) -> str:
+        """
+        The current status of the source trigger.
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class PipelineTriggerDescriptorResponse(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "sourceTrigger":
+            suggest = "source_trigger"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PipelineTriggerDescriptorResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PipelineTriggerDescriptorResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PipelineTriggerDescriptorResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 source_trigger: Optional['outputs.PipelineSourceTriggerDescriptorResponse'] = None):
+        """
+        :param 'PipelineSourceTriggerDescriptorResponse' source_trigger: The source trigger that caused the pipeline run.
+        """
+        if source_trigger is not None:
+            pulumi.set(__self__, "source_trigger", source_trigger)
+
+    @property
+    @pulumi.getter(name="sourceTrigger")
+    def source_trigger(self) -> Optional['outputs.PipelineSourceTriggerDescriptorResponse']:
+        """
+        The source trigger that caused the pipeline run.
+        """
+        return pulumi.get(self, "source_trigger")
+
+
+@pulumi.output_type
+class PipelineTriggerPropertiesResponse(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "sourceTrigger":
+            suggest = "source_trigger"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PipelineTriggerPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PipelineTriggerPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PipelineTriggerPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 source_trigger: Optional['outputs.PipelineSourceTriggerPropertiesResponse'] = None):
+        """
+        :param 'PipelineSourceTriggerPropertiesResponse' source_trigger: The source trigger properties of the pipeline.
+        """
+        if source_trigger is not None:
+            pulumi.set(__self__, "source_trigger", source_trigger)
+
+    @property
+    @pulumi.getter(name="sourceTrigger")
+    def source_trigger(self) -> Optional['outputs.PipelineSourceTriggerPropertiesResponse']:
+        """
+        The source trigger properties of the pipeline.
+        """
+        return pulumi.get(self, "source_trigger")
+
+
+@pulumi.output_type
+class PoliciesResponse(dict):
+    """
+    The policies for a container registry.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "azureADAuthenticationAsArmPolicy":
+            suggest = "azure_ad_authentication_as_arm_policy"
+        elif key == "exportPolicy":
+            suggest = "export_policy"
+        elif key == "quarantinePolicy":
+            suggest = "quarantine_policy"
+        elif key == "retentionPolicy":
+            suggest = "retention_policy"
+        elif key == "softDeletePolicy":
+            suggest = "soft_delete_policy"
+        elif key == "trustPolicy":
+            suggest = "trust_policy"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PoliciesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PoliciesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PoliciesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 azure_ad_authentication_as_arm_policy: Optional['outputs.AzureADAuthenticationAsArmPolicyResponse'] = None,
+                 export_policy: Optional['outputs.ExportPolicyResponse'] = None,
+                 quarantine_policy: Optional['outputs.QuarantinePolicyResponse'] = None,
+                 retention_policy: Optional['outputs.RetentionPolicyResponse'] = None,
+                 soft_delete_policy: Optional['outputs.SoftDeletePolicyResponse'] = None,
+                 trust_policy: Optional['outputs.TrustPolicyResponse'] = None):
+        """
+        The policies for a container registry.
+        :param 'AzureADAuthenticationAsArmPolicyResponse' azure_ad_authentication_as_arm_policy: The policy for using ARM audience token for a container registry.
+        :param 'ExportPolicyResponse' export_policy: The export policy for a container registry.
+        :param 'QuarantinePolicyResponse' quarantine_policy: The quarantine policy for a container registry.
+        :param 'RetentionPolicyResponse' retention_policy: The retention policy for a container registry.
+        :param 'SoftDeletePolicyResponse' soft_delete_policy: The soft delete policy for a container registry.
+        :param 'TrustPolicyResponse' trust_policy: The content trust policy for a container registry.
+        """
+        if azure_ad_authentication_as_arm_policy is not None:
+            pulumi.set(__self__, "azure_ad_authentication_as_arm_policy", azure_ad_authentication_as_arm_policy)
+        if export_policy is not None:
+            pulumi.set(__self__, "export_policy", export_policy)
+        if quarantine_policy is not None:
+            pulumi.set(__self__, "quarantine_policy", quarantine_policy)
+        if retention_policy is not None:
+            pulumi.set(__self__, "retention_policy", retention_policy)
+        if soft_delete_policy is not None:
+            pulumi.set(__self__, "soft_delete_policy", soft_delete_policy)
+        if trust_policy is not None:
+            pulumi.set(__self__, "trust_policy", trust_policy)
+
+    @property
+    @pulumi.getter(name="azureADAuthenticationAsArmPolicy")
+    def azure_ad_authentication_as_arm_policy(self) -> Optional['outputs.AzureADAuthenticationAsArmPolicyResponse']:
+        """
+        The policy for using ARM audience token for a container registry.
+        """
+        return pulumi.get(self, "azure_ad_authentication_as_arm_policy")
+
+    @property
+    @pulumi.getter(name="exportPolicy")
+    def export_policy(self) -> Optional['outputs.ExportPolicyResponse']:
+        """
+        The export policy for a container registry.
+        """
+        return pulumi.get(self, "export_policy")
+
+    @property
+    @pulumi.getter(name="quarantinePolicy")
+    def quarantine_policy(self) -> Optional['outputs.QuarantinePolicyResponse']:
+        """
+        The quarantine policy for a container registry.
+        """
+        return pulumi.get(self, "quarantine_policy")
+
+    @property
+    @pulumi.getter(name="retentionPolicy")
+    def retention_policy(self) -> Optional['outputs.RetentionPolicyResponse']:
+        """
+        The retention policy for a container registry.
+        """
+        return pulumi.get(self, "retention_policy")
+
+    @property
+    @pulumi.getter(name="softDeletePolicy")
+    def soft_delete_policy(self) -> Optional['outputs.SoftDeletePolicyResponse']:
+        """
+        The soft delete policy for a container registry.
+        """
+        return pulumi.get(self, "soft_delete_policy")
+
+    @property
+    @pulumi.getter(name="trustPolicy")
+    def trust_policy(self) -> Optional['outputs.TrustPolicyResponse']:
+        """
+        The content trust policy for a container registry.
+        """
+        return pulumi.get(self, "trust_policy")
+
+
+@pulumi.output_type
+class PrivateEndpointConnectionResponse(dict):
+    """
+    An object that represents a private endpoint connection for a container registry.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "provisioningState":
+            suggest = "provisioning_state"
+        elif key == "systemData":
+            suggest = "system_data"
+        elif key == "privateEndpoint":
+            suggest = "private_endpoint"
+        elif key == "privateLinkServiceConnectionState":
+            suggest = "private_link_service_connection_state"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PrivateEndpointConnectionResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PrivateEndpointConnectionResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PrivateEndpointConnectionResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 id: str,
+                 name: str,
+                 provisioning_state: str,
+                 system_data: 'outputs.SystemDataResponse',
+                 type: str,
+                 private_endpoint: Optional['outputs.PrivateEndpointResponse'] = None,
+                 private_link_service_connection_state: Optional['outputs.PrivateLinkServiceConnectionStateResponse'] = None):
+        """
+        An object that represents a private endpoint connection for a container registry.
+        :param str id: The resource ID.
+        :param str name: The name of the resource.
+        :param str provisioning_state: The provisioning state of private endpoint connection resource.
+        :param 'SystemDataResponse' system_data: Metadata pertaining to creation and last modification of the resource.
+        :param str type: The type of the resource.
+        :param 'PrivateEndpointResponse' private_endpoint: The resource of private endpoint.
+        :param 'PrivateLinkServiceConnectionStateResponse' private_link_service_connection_state: A collection of information about the state of the connection between service consumer and provider.
+        """
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "provisioning_state", provisioning_state)
+        pulumi.set(__self__, "system_data", system_data)
+        pulumi.set(__self__, "type", type)
+        if private_endpoint is not None:
+            pulumi.set(__self__, "private_endpoint", private_endpoint)
+        if private_link_service_connection_state is not None:
+            pulumi.set(__self__, "private_link_service_connection_state", private_link_service_connection_state)
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The resource ID.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of the resource.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="provisioningState")
+    def provisioning_state(self) -> str:
+        """
+        The provisioning state of private endpoint connection resource.
+        """
+        return pulumi.get(self, "provisioning_state")
+
+    @property
+    @pulumi.getter(name="systemData")
+    def system_data(self) -> 'outputs.SystemDataResponse':
+        """
+        Metadata pertaining to creation and last modification of the resource.
+        """
+        return pulumi.get(self, "system_data")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        The type of the resource.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="privateEndpoint")
+    def private_endpoint(self) -> Optional['outputs.PrivateEndpointResponse']:
+        """
+        The resource of private endpoint.
+        """
+        return pulumi.get(self, "private_endpoint")
+
+    @property
+    @pulumi.getter(name="privateLinkServiceConnectionState")
+    def private_link_service_connection_state(self) -> Optional['outputs.PrivateLinkServiceConnectionStateResponse']:
+        """
+        A collection of information about the state of the connection between service consumer and provider.
+        """
+        return pulumi.get(self, "private_link_service_connection_state")
+
+
+@pulumi.output_type
+class PrivateEndpointResponse(dict):
+    """
+    The Private Endpoint resource.
+    """
+    def __init__(__self__, *,
+                 id: Optional[str] = None):
+        """
+        The Private Endpoint resource.
+        :param str id: This is private endpoint resource created with Microsoft.Network resource provider.
+        """
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[str]:
+        """
+        This is private endpoint resource created with Microsoft.Network resource provider.
+        """
+        return pulumi.get(self, "id")
+
+
+@pulumi.output_type
+class PrivateLinkServiceConnectionStateResponse(dict):
+    """
+    The state of a private link service connection.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "actionsRequired":
+            suggest = "actions_required"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in PrivateLinkServiceConnectionStateResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        PrivateLinkServiceConnectionStateResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        PrivateLinkServiceConnectionStateResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 actions_required: Optional[str] = None,
+                 description: Optional[str] = None,
+                 status: Optional[str] = None):
+        """
+        The state of a private link service connection.
+        :param str actions_required: A message indicating if changes on the service provider require any updates on the consumer.
+        :param str description: The description for connection status. For example if connection is rejected it can indicate reason for rejection.
+        :param str status: The private link service connection status.
+        """
+        if actions_required is not None:
+            pulumi.set(__self__, "actions_required", actions_required)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter(name="actionsRequired")
+    def actions_required(self) -> Optional[str]:
+        """
+        A message indicating if changes on the service provider require any updates on the consumer.
+        """
+        return pulumi.get(self, "actions_required")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[str]:
+        """
+        The description for connection status. For example if connection is rejected it can indicate reason for rejection.
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[str]:
+        """
+        The private link service connection status.
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class ProgressPropertiesResponse(dict):
+    def __init__(__self__, *,
+                 percentage: Optional[str] = None):
+        """
+        :param str percentage: The percentage complete of the copy operation.
+        """
+        if percentage is not None:
+            pulumi.set(__self__, "percentage", percentage)
+
+    @property
+    @pulumi.getter
+    def percentage(self) -> Optional[str]:
+        """
+        The percentage complete of the copy operation.
+        """
+        return pulumi.get(self, "percentage")
+
+
+@pulumi.output_type
+class QuarantinePolicyResponse(dict):
+    """
+    The quarantine policy for a container registry.
+    """
+    def __init__(__self__, *,
+                 status: Optional[str] = None):
+        """
+        The quarantine policy for a container registry.
+        :param str status: The value that indicates whether the policy is enabled or not.
+        """
+        if status is None:
+            status = 'disabled'
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[str]:
+        """
+        The value that indicates whether the policy is enabled or not.
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class RegistryPasswordResponse(dict):
+    """
+    The login password for the container registry.
+    """
+    def __init__(__self__, *,
+                 name: Optional[str] = None,
+                 value: Optional[str] = None):
+        """
+        The login password for the container registry.
+        :param str name: The password name.
+        :param str value: The password value.
+        """
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        The password name.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def value(self) -> Optional[str]:
+        """
+        The password value.
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class RequestResponse(dict):
+    """
+    The request that generated the event.
+    """
+    def __init__(__self__, *,
+                 addr: Optional[str] = None,
+                 host: Optional[str] = None,
+                 id: Optional[str] = None,
+                 method: Optional[str] = None,
+                 useragent: Optional[str] = None):
+        """
+        The request that generated the event.
+        :param str addr: The IP or hostname and possibly port of the client connection that initiated the event. This is the RemoteAddr from the standard http request.
+        :param str host: The externally accessible hostname of the registry instance, as specified by the http host header on incoming requests.
+        :param str id: The ID of the request that initiated the event.
+        :param str method: The request method that generated the event.
+        :param str useragent: The user agent header of the request.
+        """
+        if addr is not None:
+            pulumi.set(__self__, "addr", addr)
+        if host is not None:
+            pulumi.set(__self__, "host", host)
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if method is not None:
+            pulumi.set(__self__, "method", method)
+        if useragent is not None:
+            pulumi.set(__self__, "useragent", useragent)
+
+    @property
+    @pulumi.getter
+    def addr(self) -> Optional[str]:
+        """
+        The IP or hostname and possibly port of the client connection that initiated the event. This is the RemoteAddr from the standard http request.
+        """
+        return pulumi.get(self, "addr")
+
+    @property
+    @pulumi.getter
+    def host(self) -> Optional[str]:
+        """
+        The externally accessible hostname of the registry instance, as specified by the http host header on incoming requests.
+        """
+        return pulumi.get(self, "host")
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[str]:
+        """
+        The ID of the request that initiated the event.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def method(self) -> Optional[str]:
+        """
+        The request method that generated the event.
+        """
+        return pulumi.get(self, "method")
+
+    @property
+    @pulumi.getter
+    def useragent(self) -> Optional[str]:
+        """
+        The user agent header of the request.
+        """
+        return pulumi.get(self, "useragent")
+
+
+@pulumi.output_type
+class RetentionPolicyResponse(dict):
+    """
+    The retention policy for a container registry.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "lastUpdatedTime":
+            suggest = "last_updated_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in RetentionPolicyResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        RetentionPolicyResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        RetentionPolicyResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 last_updated_time: str,
+                 days: Optional[int] = None,
+                 status: Optional[str] = None):
+        """
+        The retention policy for a container registry.
+        :param str last_updated_time: The timestamp when the policy was last updated.
+        :param int days: The number of days to retain an untagged manifest after which it gets purged.
+        :param str status: The value that indicates whether the policy is enabled or not.
+        """
+        pulumi.set(__self__, "last_updated_time", last_updated_time)
+        if days is None:
+            days = 7
+        if days is not None:
+            pulumi.set(__self__, "days", days)
+        if status is None:
+            status = 'disabled'
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter(name="lastUpdatedTime")
+    def last_updated_time(self) -> str:
+        """
+        The timestamp when the policy was last updated.
+        """
+        return pulumi.get(self, "last_updated_time")
+
+    @property
+    @pulumi.getter
+    def days(self) -> Optional[int]:
+        """
+        The number of days to retain an untagged manifest after which it gets purged.
+        """
+        return pulumi.get(self, "days")
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[str]:
+        """
+        The value that indicates whether the policy is enabled or not.
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class SkuResponse(dict):
+    """
+    The SKU of a container registry.
+    """
+    def __init__(__self__, *,
+                 name: str,
+                 tier: str):
+        """
+        The SKU of a container registry.
+        :param str name: The SKU name of the container registry. Required for registry creation.
+        :param str tier: The SKU tier based on the SKU name.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "tier", tier)
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The SKU name of the container registry. Required for registry creation.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def tier(self) -> str:
+        """
+        The SKU tier based on the SKU name.
+        """
+        return pulumi.get(self, "tier")
+
+
+@pulumi.output_type
+class SoftDeletePolicyResponse(dict):
+    """
+    The soft delete policy for a container registry
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "lastUpdatedTime":
+            suggest = "last_updated_time"
+        elif key == "retentionDays":
+            suggest = "retention_days"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SoftDeletePolicyResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SoftDeletePolicyResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SoftDeletePolicyResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 last_updated_time: str,
+                 retention_days: Optional[int] = None,
+                 status: Optional[str] = None):
+        """
+        The soft delete policy for a container registry
+        :param str last_updated_time: The timestamp when the policy was last updated.
+        :param int retention_days: The number of days after which a soft-deleted item is permanently deleted.
+        :param str status: The value that indicates whether the policy is enabled or not.
+        """
+        pulumi.set(__self__, "last_updated_time", last_updated_time)
+        if retention_days is None:
+            retention_days = 7
+        if retention_days is not None:
+            pulumi.set(__self__, "retention_days", retention_days)
+        if status is None:
+            status = 'disabled'
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter(name="lastUpdatedTime")
+    def last_updated_time(self) -> str:
+        """
+        The timestamp when the policy was last updated.
+        """
+        return pulumi.get(self, "last_updated_time")
+
+    @property
+    @pulumi.getter(name="retentionDays")
+    def retention_days(self) -> Optional[int]:
+        """
+        The number of days after which a soft-deleted item is permanently deleted.
+        """
+        return pulumi.get(self, "retention_days")
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[str]:
+        """
+        The value that indicates whether the policy is enabled or not.
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class SourceResponse(dict):
+    """
+    The registry node that generated the event. Put differently, while the actor initiates the event, the source generates it.
+    """
+    def __init__(__self__, *,
+                 addr: Optional[str] = None,
+                 instance_id: Optional[str] = None):
+        """
+        The registry node that generated the event. Put differently, while the actor initiates the event, the source generates it.
+        :param str addr: The IP or hostname and the port of the registry node that generated the event. Generally, this will be resolved by os.Hostname() along with the running port.
+        :param str instance_id: The running instance of an application. Changes after each restart.
+        """
+        if addr is not None:
+            pulumi.set(__self__, "addr", addr)
+        if instance_id is not None:
+            pulumi.set(__self__, "instance_id", instance_id)
+
+    @property
+    @pulumi.getter
+    def addr(self) -> Optional[str]:
+        """
+        The IP or hostname and the port of the registry node that generated the event. Generally, this will be resolved by os.Hostname() along with the running port.
+        """
+        return pulumi.get(self, "addr")
+
+    @property
+    @pulumi.getter(name="instanceID")
+    def instance_id(self) -> Optional[str]:
+        """
+        The running instance of an application. Changes after each restart.
+        """
+        return pulumi.get(self, "instance_id")
+
+
+@pulumi.output_type
+class StatusDetailPropertiesResponse(dict):
+    """
+    The status detail properties of the connected registry.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "correlationId":
+            suggest = "correlation_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in StatusDetailPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        StatusDetailPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        StatusDetailPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 code: str,
+                 correlation_id: str,
+                 description: str,
+                 timestamp: str,
+                 type: str):
+        """
+        The status detail properties of the connected registry.
+        :param str code: The code of the status.
+        :param str correlation_id: The correlation ID of the status.
+        :param str description: The description of the status.
+        :param str timestamp: The timestamp of the status.
+        :param str type: The component of the connected registry corresponding to the status.
+        """
+        pulumi.set(__self__, "code", code)
+        pulumi.set(__self__, "correlation_id", correlation_id)
+        pulumi.set(__self__, "description", description)
+        pulumi.set(__self__, "timestamp", timestamp)
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def code(self) -> str:
+        """
+        The code of the status.
+        """
+        return pulumi.get(self, "code")
+
+    @property
+    @pulumi.getter(name="correlationId")
+    def correlation_id(self) -> str:
+        """
+        The correlation ID of the status.
+        """
+        return pulumi.get(self, "correlation_id")
+
+    @property
+    @pulumi.getter
+    def description(self) -> str:
+        """
+        The description of the status.
+        """
+        return pulumi.get(self, "description")
+
+    @property
+    @pulumi.getter
+    def timestamp(self) -> str:
+        """
+        The timestamp of the status.
+        """
+        return pulumi.get(self, "timestamp")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        The component of the connected registry corresponding to the status.
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class StatusResponse(dict):
+    """
+    The status of an Azure resource at the time the operation was called.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "displayStatus":
+            suggest = "display_status"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in StatusResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        StatusResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        StatusResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 display_status: str,
+                 message: str,
+                 timestamp: str):
+        """
+        The status of an Azure resource at the time the operation was called.
+        :param str display_status: The short label for the status.
+        :param str message: The detailed message for the status, including alerts and error messages.
+        :param str timestamp: The timestamp when the status was changed to the current value.
+        """
+        pulumi.set(__self__, "display_status", display_status)
+        pulumi.set(__self__, "message", message)
+        pulumi.set(__self__, "timestamp", timestamp)
+
+    @property
+    @pulumi.getter(name="displayStatus")
+    def display_status(self) -> str:
+        """
+        The short label for the status.
+        """
+        return pulumi.get(self, "display_status")
+
+    @property
+    @pulumi.getter
+    def message(self) -> str:
+        """
+        The detailed message for the status, including alerts and error messages.
+        """
+        return pulumi.get(self, "message")
+
+    @property
+    @pulumi.getter
+    def timestamp(self) -> str:
+        """
+        The timestamp when the status was changed to the current value.
+        """
+        return pulumi.get(self, "timestamp")
+
+
+@pulumi.output_type
+class SyncPropertiesResponse(dict):
+    """
+    The sync properties of the connected registry with its parent.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "gatewayEndpoint":
+            suggest = "gateway_endpoint"
+        elif key == "lastSyncTime":
+            suggest = "last_sync_time"
+        elif key == "messageTtl":
+            suggest = "message_ttl"
+        elif key == "tokenId":
+            suggest = "token_id"
+        elif key == "syncWindow":
+            suggest = "sync_window"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SyncPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SyncPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SyncPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 gateway_endpoint: str,
+                 last_sync_time: str,
+                 message_ttl: str,
+                 token_id: str,
+                 schedule: Optional[str] = None,
+                 sync_window: Optional[str] = None):
+        """
+        The sync properties of the connected registry with its parent.
+        :param str gateway_endpoint: The gateway endpoint used by the connected registry to communicate with its parent.
+        :param str last_sync_time: The last time a sync occurred between the connected registry and its parent.
+        :param str message_ttl: The period of time for which a message is available to sync before it is expired. Specify the duration using the format P[n]Y[n]M[n]DT[n]H[n]M[n]S as per ISO8601.
+        :param str token_id: The resource ID of the ACR token used to authenticate the connected registry to its parent during sync.
+        :param str schedule: The cron expression indicating the schedule that the connected registry will sync with its parent.
+        :param str sync_window: The time window during which sync is enabled for each schedule occurrence. Specify the duration using the format P[n]Y[n]M[n]DT[n]H[n]M[n]S as per ISO8601.
+        """
+        pulumi.set(__self__, "gateway_endpoint", gateway_endpoint)
+        pulumi.set(__self__, "last_sync_time", last_sync_time)
+        pulumi.set(__self__, "message_ttl", message_ttl)
+        pulumi.set(__self__, "token_id", token_id)
+        if schedule is not None:
+            pulumi.set(__self__, "schedule", schedule)
+        if sync_window is not None:
+            pulumi.set(__self__, "sync_window", sync_window)
+
+    @property
+    @pulumi.getter(name="gatewayEndpoint")
+    def gateway_endpoint(self) -> str:
+        """
+        The gateway endpoint used by the connected registry to communicate with its parent.
+        """
+        return pulumi.get(self, "gateway_endpoint")
+
+    @property
+    @pulumi.getter(name="lastSyncTime")
+    def last_sync_time(self) -> str:
+        """
+        The last time a sync occurred between the connected registry and its parent.
+        """
+        return pulumi.get(self, "last_sync_time")
+
+    @property
+    @pulumi.getter(name="messageTtl")
+    def message_ttl(self) -> str:
+        """
+        The period of time for which a message is available to sync before it is expired. Specify the duration using the format P[n]Y[n]M[n]DT[n]H[n]M[n]S as per ISO8601.
+        """
+        return pulumi.get(self, "message_ttl")
+
+    @property
+    @pulumi.getter(name="tokenId")
+    def token_id(self) -> str:
+        """
+        The resource ID of the ACR token used to authenticate the connected registry to its parent during sync.
+        """
+        return pulumi.get(self, "token_id")
+
+    @property
+    @pulumi.getter
+    def schedule(self) -> Optional[str]:
+        """
+        The cron expression indicating the schedule that the connected registry will sync with its parent.
+        """
+        return pulumi.get(self, "schedule")
+
+    @property
+    @pulumi.getter(name="syncWindow")
+    def sync_window(self) -> Optional[str]:
+        """
+        The time window during which sync is enabled for each schedule occurrence. Specify the duration using the format P[n]Y[n]M[n]DT[n]H[n]M[n]S as per ISO8601.
+        """
+        return pulumi.get(self, "sync_window")
+
+
+@pulumi.output_type
+class SystemDataResponse(dict):
+    """
+    Metadata pertaining to creation and last modification of the resource.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "createdAt":
+            suggest = "created_at"
+        elif key == "createdBy":
+            suggest = "created_by"
+        elif key == "createdByType":
+            suggest = "created_by_type"
+        elif key == "lastModifiedAt":
+            suggest = "last_modified_at"
+        elif key == "lastModifiedBy":
+            suggest = "last_modified_by"
+        elif key == "lastModifiedByType":
+            suggest = "last_modified_by_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SystemDataResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SystemDataResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SystemDataResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 created_at: Optional[str] = None,
+                 created_by: Optional[str] = None,
+                 created_by_type: Optional[str] = None,
+                 last_modified_at: Optional[str] = None,
+                 last_modified_by: Optional[str] = None,
+                 last_modified_by_type: Optional[str] = None):
+        """
+        Metadata pertaining to creation and last modification of the resource.
+        :param str created_at: The timestamp of resource creation (UTC).
+        :param str created_by: The identity that created the resource.
+        :param str created_by_type: The type of identity that created the resource.
+        :param str last_modified_at: The timestamp of resource modification (UTC).
+        :param str last_modified_by: The identity that last modified the resource.
+        :param str last_modified_by_type: The type of identity that last modified the resource.
+        """
+        if created_at is not None:
+            pulumi.set(__self__, "created_at", created_at)
+        if created_by is not None:
+            pulumi.set(__self__, "created_by", created_by)
+        if created_by_type is not None:
+            pulumi.set(__self__, "created_by_type", created_by_type)
+        if last_modified_at is not None:
+            pulumi.set(__self__, "last_modified_at", last_modified_at)
+        if last_modified_by is not None:
+            pulumi.set(__self__, "last_modified_by", last_modified_by)
+        if last_modified_by_type is not None:
+            pulumi.set(__self__, "last_modified_by_type", last_modified_by_type)
+
+    @property
+    @pulumi.getter(name="createdAt")
+    def created_at(self) -> Optional[str]:
+        """
+        The timestamp of resource creation (UTC).
+        """
+        return pulumi.get(self, "created_at")
+
+    @property
+    @pulumi.getter(name="createdBy")
+    def created_by(self) -> Optional[str]:
+        """
+        The identity that created the resource.
+        """
+        return pulumi.get(self, "created_by")
+
+    @property
+    @pulumi.getter(name="createdByType")
+    def created_by_type(self) -> Optional[str]:
+        """
+        The type of identity that created the resource.
+        """
+        return pulumi.get(self, "created_by_type")
+
+    @property
+    @pulumi.getter(name="lastModifiedAt")
+    def last_modified_at(self) -> Optional[str]:
+        """
+        The timestamp of resource modification (UTC).
+        """
+        return pulumi.get(self, "last_modified_at")
+
+    @property
+    @pulumi.getter(name="lastModifiedBy")
+    def last_modified_by(self) -> Optional[str]:
+        """
+        The identity that last modified the resource.
+        """
+        return pulumi.get(self, "last_modified_by")
+
+    @property
+    @pulumi.getter(name="lastModifiedByType")
+    def last_modified_by_type(self) -> Optional[str]:
+        """
+        The type of identity that last modified the resource.
+        """
+        return pulumi.get(self, "last_modified_by_type")
+
+
+@pulumi.output_type
+class TargetResponse(dict):
+    """
+    The target of the event.
+    """
+    def __init__(__self__, *,
+                 digest: Optional[str] = None,
+                 length: Optional[float] = None,
+                 media_type: Optional[str] = None,
+                 name: Optional[str] = None,
+                 repository: Optional[str] = None,
+                 size: Optional[float] = None,
+                 tag: Optional[str] = None,
+                 url: Optional[str] = None,
+                 version: Optional[str] = None):
+        """
+        The target of the event.
+        :param str digest: The digest of the content, as defined by the Registry V2 HTTP API Specification.
+        :param float length: The number of bytes of the content. Same as Size field.
+        :param str media_type: The MIME type of the referenced object.
+        :param str name: The name of the artifact.
+        :param str repository: The repository name.
+        :param float size: The number of bytes of the content. Same as Length field.
+        :param str tag: The tag name.
+        :param str url: The direct URL to the content.
+        :param str version: The version of the artifact.
+        """
+        if digest is not None:
+            pulumi.set(__self__, "digest", digest)
+        if length is not None:
+            pulumi.set(__self__, "length", length)
+        if media_type is not None:
+            pulumi.set(__self__, "media_type", media_type)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if repository is not None:
+            pulumi.set(__self__, "repository", repository)
+        if size is not None:
+            pulumi.set(__self__, "size", size)
+        if tag is not None:
+            pulumi.set(__self__, "tag", tag)
+        if url is not None:
+            pulumi.set(__self__, "url", url)
+        if version is not None:
+            pulumi.set(__self__, "version", version)
+
+    @property
+    @pulumi.getter
+    def digest(self) -> Optional[str]:
+        """
+        The digest of the content, as defined by the Registry V2 HTTP API Specification.
+        """
+        return pulumi.get(self, "digest")
+
+    @property
+    @pulumi.getter
+    def length(self) -> Optional[float]:
+        """
+        The number of bytes of the content. Same as Size field.
+        """
+        return pulumi.get(self, "length")
+
+    @property
+    @pulumi.getter(name="mediaType")
+    def media_type(self) -> Optional[str]:
+        """
+        The MIME type of the referenced object.
+        """
+        return pulumi.get(self, "media_type")
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        The name of the artifact.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def repository(self) -> Optional[str]:
+        """
+        The repository name.
+        """
+        return pulumi.get(self, "repository")
+
+    @property
+    @pulumi.getter
+    def size(self) -> Optional[float]:
+        """
+        The number of bytes of the content. Same as Length field.
+        """
+        return pulumi.get(self, "size")
+
+    @property
+    @pulumi.getter
+    def tag(self) -> Optional[str]:
+        """
+        The tag name.
+        """
+        return pulumi.get(self, "tag")
+
+    @property
+    @pulumi.getter
+    def url(self) -> Optional[str]:
+        """
+        The direct URL to the content.
+        """
+        return pulumi.get(self, "url")
+
+    @property
+    @pulumi.getter
+    def version(self) -> Optional[str]:
+        """
+        The version of the artifact.
+        """
+        return pulumi.get(self, "version")
+
+
+@pulumi.output_type
+class TlsCertificatePropertiesResponse(dict):
+    """
+    The TLS certificate properties of the connected registry login server.
+    """
+    def __init__(__self__, *,
+                 location: str,
+                 type: str):
+        """
+        The TLS certificate properties of the connected registry login server.
+        :param str location: Indicates the location of the certificates.
+        :param str type: The type of certificate location.
+        """
+        pulumi.set(__self__, "location", location)
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def location(self) -> str:
+        """
+        Indicates the location of the certificates.
+        """
+        return pulumi.get(self, "location")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        The type of certificate location.
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class TlsPropertiesResponse(dict):
+    """
+    The TLS properties of the connected registry login server.
+    """
+    def __init__(__self__, *,
+                 certificate: 'outputs.TlsCertificatePropertiesResponse',
+                 status: str):
+        """
+        The TLS properties of the connected registry login server.
+        :param 'TlsCertificatePropertiesResponse' certificate: The certificate used to configure HTTPS for the login server.
+        :param str status: Indicates whether HTTPS is enabled for the login server.
+        """
+        pulumi.set(__self__, "certificate", certificate)
+        pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter
+    def certificate(self) -> 'outputs.TlsCertificatePropertiesResponse':
+        """
+        The certificate used to configure HTTPS for the login server.
+        """
+        return pulumi.get(self, "certificate")
+
+    @property
+    @pulumi.getter
+    def status(self) -> str:
+        """
+        Indicates whether HTTPS is enabled for the login server.
+        """
+        return pulumi.get(self, "status")
+
+
+@pulumi.output_type
+class TokenCertificateResponse(dict):
+    """
+    The properties of a certificate used for authenticating a token.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "encodedPemCertificate":
+            suggest = "encoded_pem_certificate"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in TokenCertificateResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        TokenCertificateResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        TokenCertificateResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 encoded_pem_certificate: Optional[str] = None,
+                 expiry: Optional[str] = None,
+                 name: Optional[str] = None,
+                 thumbprint: Optional[str] = None):
+        """
+        The properties of a certificate used for authenticating a token.
+        :param str encoded_pem_certificate: Base 64 encoded string of the public certificate1 in PEM format that will be used for authenticating the token.
+        :param str expiry: The expiry datetime of the certificate.
+        :param str thumbprint: The thumbprint of the certificate.
+        """
+        if encoded_pem_certificate is not None:
+            pulumi.set(__self__, "encoded_pem_certificate", encoded_pem_certificate)
+        if expiry is not None:
+            pulumi.set(__self__, "expiry", expiry)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if thumbprint is not None:
+            pulumi.set(__self__, "thumbprint", thumbprint)
+
+    @property
+    @pulumi.getter(name="encodedPemCertificate")
+    def encoded_pem_certificate(self) -> Optional[str]:
+        """
+        Base 64 encoded string of the public certificate1 in PEM format that will be used for authenticating the token.
+        """
+        return pulumi.get(self, "encoded_pem_certificate")
+
+    @property
+    @pulumi.getter
+    def expiry(self) -> Optional[str]:
+        """
+        The expiry datetime of the certificate.
+        """
+        return pulumi.get(self, "expiry")
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def thumbprint(self) -> Optional[str]:
+        """
+        The thumbprint of the certificate.
+        """
+        return pulumi.get(self, "thumbprint")
+
+
+@pulumi.output_type
+class TokenCredentialsPropertiesResponse(dict):
+    """
+    The properties of the credentials that can be used for authenticating the token.
+    """
+    def __init__(__self__, *,
+                 certificates: Optional[Sequence['outputs.TokenCertificateResponse']] = None,
+                 passwords: Optional[Sequence['outputs.TokenPasswordResponse']] = None):
+        """
+        The properties of the credentials that can be used for authenticating the token.
+        """
+        if certificates is not None:
+            pulumi.set(__self__, "certificates", certificates)
+        if passwords is not None:
+            pulumi.set(__self__, "passwords", passwords)
+
+    @property
+    @pulumi.getter
+    def certificates(self) -> Optional[Sequence['outputs.TokenCertificateResponse']]:
+        return pulumi.get(self, "certificates")
+
+    @property
+    @pulumi.getter
+    def passwords(self) -> Optional[Sequence['outputs.TokenPasswordResponse']]:
+        return pulumi.get(self, "passwords")
+
+
+@pulumi.output_type
+class TokenPasswordResponse(dict):
+    """
+    The password that will be used for authenticating the token of a container registry.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "creationTime":
+            suggest = "creation_time"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in TokenPasswordResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        TokenPasswordResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        TokenPasswordResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 value: str,
+                 creation_time: Optional[str] = None,
+                 expiry: Optional[str] = None,
+                 name: Optional[str] = None):
+        """
+        The password that will be used for authenticating the token of a container registry.
+        :param str value: The password value.
+        :param str creation_time: The creation datetime of the password.
+        :param str expiry: The expiry datetime of the password.
+        :param str name: The password name "password1" or "password2"
+        """
+        pulumi.set(__self__, "value", value)
+        if creation_time is not None:
+            pulumi.set(__self__, "creation_time", creation_time)
+        if expiry is not None:
+            pulumi.set(__self__, "expiry", expiry)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+
+    @property
+    @pulumi.getter
+    def value(self) -> str:
+        """
+        The password value.
+        """
+        return pulumi.get(self, "value")
+
+    @property
+    @pulumi.getter(name="creationTime")
+    def creation_time(self) -> Optional[str]:
+        """
+        The creation datetime of the password.
+        """
+        return pulumi.get(self, "creation_time")
+
+    @property
+    @pulumi.getter
+    def expiry(self) -> Optional[str]:
+        """
+        The expiry datetime of the password.
+        """
+        return pulumi.get(self, "expiry")
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        The password name "password1" or "password2"
+        """
+        return pulumi.get(self, "name")
+
+
+@pulumi.output_type
+class TrustPolicyResponse(dict):
+    """
+    The content trust policy for a container registry.
+    """
+    def __init__(__self__, *,
+                 status: Optional[str] = None,
+                 type: Optional[str] = None):
+        """
+        The content trust policy for a container registry.
+        :param str status: The value that indicates whether the policy is enabled or not.
+        :param str type: The type of trust policy.
+        """
+        if status is None:
+            status = 'disabled'
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+        if type is None:
+            type = 'Notary'
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def status(self) -> Optional[str]:
+        """
+        The value that indicates whether the policy is enabled or not.
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        The type of trust policy.
+        """
+        return pulumi.get(self, "type")
+
+
+@pulumi.output_type
+class UserIdentityPropertiesResponse(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "clientId":
+            suggest = "client_id"
+        elif key == "principalId":
+            suggest = "principal_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in UserIdentityPropertiesResponse. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        UserIdentityPropertiesResponse.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        UserIdentityPropertiesResponse.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 client_id: str,
+                 principal_id: str):
+        """
+        :param str client_id: The client id of user assigned identity.
+        :param str principal_id: The principal id of user assigned identity.
+        """
+        pulumi.set(__self__, "client_id", client_id)
+        pulumi.set(__self__, "principal_id", principal_id)
+
+    @property
+    @pulumi.getter(name="clientId")
+    def client_id(self) -> str:
+        """
+        The client id of user assigned identity.
+        """
+        return pulumi.get(self, "client_id")
+
+    @property
+    @pulumi.getter(name="principalId")
+    def principal_id(self) -> str:
+        """
+        The principal id of user assigned identity.
+        """
+        return pulumi.get(self, "principal_id")
+
+