pulumi-azure-native 2.89.0a1740029202__py3-none-any.whl → 2.89.0a1740591573__py3-none-any.whl

pulumi_azure_native/authorization/v20201001/_enums.py

@@ -10,7 +10,9 @@ __all__ = [
     'NotificationDeliveryMechanism',
     'NotificationLevel',
     'RecipientType',
+    'RequestType',
     'RoleManagementPolicyRuleType',
+    'Type',
     'UserType',
 ]
 
@@ -59,6 +61,21 @@ class RecipientType(str, Enum):
     ADMIN = "Admin"
 
 
+class RequestType(str, Enum):
+    """
+    The type of the role assignment schedule request. Eg: SelfActivate, AdminAssign etc
+    """
+    ADMIN_ASSIGN = "AdminAssign"
+    ADMIN_REMOVE = "AdminRemove"
+    ADMIN_UPDATE = "AdminUpdate"
+    ADMIN_EXTEND = "AdminExtend"
+    ADMIN_RENEW = "AdminRenew"
+    SELF_ACTIVATE = "SelfActivate"
+    SELF_DEACTIVATE = "SelfDeactivate"
+    SELF_EXTEND = "SelfExtend"
+    SELF_RENEW = "SelfRenew"
+
+
 class RoleManagementPolicyRuleType(str, Enum):
     """
     The type of rule
@@ -70,6 +87,15 @@ class RoleManagementPolicyRuleType(str, Enum):
     ROLE_MANAGEMENT_POLICY_NOTIFICATION_RULE = "RoleManagementPolicyNotificationRule"
 
 
+class Type(str, Enum):
+    """
+    Type of the role eligibility schedule expiration
+    """
+    AFTER_DURATION = "AfterDuration"
+    AFTER_DATE_TIME = "AfterDateTime"
+    NO_EXPIRATION = "NoExpiration"
+
+
 class UserType(str, Enum):
     """
     The type of user.

pulumi_azure_native/authorization/v20201001/_inputs.py

@@ -20,6 +20,12 @@ __all__ = [
     'ApprovalSettingsArgsDict',
     'ApprovalStageArgs',
     'ApprovalStageArgsDict',
+    'RoleEligibilityScheduleRequestPropertiesExpirationArgs',
+    'RoleEligibilityScheduleRequestPropertiesExpirationArgsDict',
+    'RoleEligibilityScheduleRequestPropertiesScheduleInfoArgs',
+    'RoleEligibilityScheduleRequestPropertiesScheduleInfoArgsDict',
+    'RoleEligibilityScheduleRequestPropertiesTicketInfoArgs',
+    'RoleEligibilityScheduleRequestPropertiesTicketInfoArgsDict',
     'RoleManagementPolicyApprovalRuleArgs',
     'RoleManagementPolicyApprovalRuleArgsDict',
     'RoleManagementPolicyAuthenticationContextRuleArgs',
@@ -290,6 +296,194 @@ class ApprovalStageArgs:
         pulumi.set(self, "primary_approvers", value)
 
 
+if not MYPY:
+    class RoleEligibilityScheduleRequestPropertiesExpirationArgsDict(TypedDict):
+        """
+        Expiration of the role eligibility schedule
+        """
+        duration: NotRequired[pulumi.Input[str]]
+        """
+        Duration of the role eligibility schedule in TimeSpan.
+        """
+        end_date_time: NotRequired[pulumi.Input[str]]
+        """
+        End DateTime of the role eligibility schedule.
+        """
+        type: NotRequired[pulumi.Input[Union[str, 'Type']]]
+        """
+        Type of the role eligibility schedule expiration
+        """
+elif False:
+    RoleEligibilityScheduleRequestPropertiesExpirationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RoleEligibilityScheduleRequestPropertiesExpirationArgs:
+    def __init__(__self__, *,
+                 duration: Optional[pulumi.Input[str]] = None,
+                 end_date_time: Optional[pulumi.Input[str]] = None,
+                 type: Optional[pulumi.Input[Union[str, 'Type']]] = None):
+        """
+        Expiration of the role eligibility schedule
+        :param pulumi.Input[str] duration: Duration of the role eligibility schedule in TimeSpan.
+        :param pulumi.Input[str] end_date_time: End DateTime of the role eligibility schedule.
+        :param pulumi.Input[Union[str, 'Type']] type: Type of the role eligibility schedule expiration
+        """
+        if duration is not None:
+            pulumi.set(__self__, "duration", duration)
+        if end_date_time is not None:
+            pulumi.set(__self__, "end_date_time", end_date_time)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter
+    def duration(self) -> Optional[pulumi.Input[str]]:
+        """
+        Duration of the role eligibility schedule in TimeSpan.
+        """
+        return pulumi.get(self, "duration")
+
+    @duration.setter
+    def duration(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "duration", value)
+
+    @property
+    @pulumi.getter(name="endDateTime")
+    def end_date_time(self) -> Optional[pulumi.Input[str]]:
+        """
+        End DateTime of the role eligibility schedule.
+        """
+        return pulumi.get(self, "end_date_time")
+
+    @end_date_time.setter
+    def end_date_time(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "end_date_time", value)
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[pulumi.Input[Union[str, 'Type']]]:
+        """
+        Type of the role eligibility schedule expiration
+        """
+        return pulumi.get(self, "type")
+
+    @type.setter
+    def type(self, value: Optional[pulumi.Input[Union[str, 'Type']]]):
+        pulumi.set(self, "type", value)
+
+
+if not MYPY:
+    class RoleEligibilityScheduleRequestPropertiesScheduleInfoArgsDict(TypedDict):
+        """
+        Schedule info of the role eligibility schedule
+        """
+        expiration: NotRequired[pulumi.Input['RoleEligibilityScheduleRequestPropertiesExpirationArgsDict']]
+        """
+        Expiration of the role eligibility schedule
+        """
+        start_date_time: NotRequired[pulumi.Input[str]]
+        """
+        Start DateTime of the role eligibility schedule.
+        """
+elif False:
+    RoleEligibilityScheduleRequestPropertiesScheduleInfoArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RoleEligibilityScheduleRequestPropertiesScheduleInfoArgs:
+    def __init__(__self__, *,
+                 expiration: Optional[pulumi.Input['RoleEligibilityScheduleRequestPropertiesExpirationArgs']] = None,
+                 start_date_time: Optional[pulumi.Input[str]] = None):
+        """
+        Schedule info of the role eligibility schedule
+        :param pulumi.Input['RoleEligibilityScheduleRequestPropertiesExpirationArgs'] expiration: Expiration of the role eligibility schedule
+        :param pulumi.Input[str] start_date_time: Start DateTime of the role eligibility schedule.
+        """
+        if expiration is not None:
+            pulumi.set(__self__, "expiration", expiration)
+        if start_date_time is not None:
+            pulumi.set(__self__, "start_date_time", start_date_time)
+
+    @property
+    @pulumi.getter
+    def expiration(self) -> Optional[pulumi.Input['RoleEligibilityScheduleRequestPropertiesExpirationArgs']]:
+        """
+        Expiration of the role eligibility schedule
+        """
+        return pulumi.get(self, "expiration")
+
+    @expiration.setter
+    def expiration(self, value: Optional[pulumi.Input['RoleEligibilityScheduleRequestPropertiesExpirationArgs']]):
+        pulumi.set(self, "expiration", value)
+
+    @property
+    @pulumi.getter(name="startDateTime")
+    def start_date_time(self) -> Optional[pulumi.Input[str]]:
+        """
+        Start DateTime of the role eligibility schedule.
+        """
+        return pulumi.get(self, "start_date_time")
+
+    @start_date_time.setter
+    def start_date_time(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "start_date_time", value)
+
+
+if not MYPY:
+    class RoleEligibilityScheduleRequestPropertiesTicketInfoArgsDict(TypedDict):
+        """
+        Ticket Info of the role eligibility
+        """
+        ticket_number: NotRequired[pulumi.Input[str]]
+        """
+        Ticket number for the role eligibility
+        """
+        ticket_system: NotRequired[pulumi.Input[str]]
+        """
+        Ticket system name for the role eligibility
+        """
+elif False:
+    RoleEligibilityScheduleRequestPropertiesTicketInfoArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class RoleEligibilityScheduleRequestPropertiesTicketInfoArgs:
+    def __init__(__self__, *,
+                 ticket_number: Optional[pulumi.Input[str]] = None,
+                 ticket_system: Optional[pulumi.Input[str]] = None):
+        """
+        Ticket Info of the role eligibility
+        :param pulumi.Input[str] ticket_number: Ticket number for the role eligibility
+        :param pulumi.Input[str] ticket_system: Ticket system name for the role eligibility
+        """
+        if ticket_number is not None:
+            pulumi.set(__self__, "ticket_number", ticket_number)
+        if ticket_system is not None:
+            pulumi.set(__self__, "ticket_system", ticket_system)
+
+    @property
+    @pulumi.getter(name="ticketNumber")
+    def ticket_number(self) -> Optional[pulumi.Input[str]]:
+        """
+        Ticket number for the role eligibility
+        """
+        return pulumi.get(self, "ticket_number")
+
+    @ticket_number.setter
+    def ticket_number(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "ticket_number", value)
+
+    @property
+    @pulumi.getter(name="ticketSystem")
+    def ticket_system(self) -> Optional[pulumi.Input[str]]:
+        """
+        Ticket system name for the role eligibility
+        """
+        return pulumi.get(self, "ticket_system")
+
+    @ticket_system.setter
+    def ticket_system(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "ticket_system", value)
+
+
 if not MYPY:
     class RoleManagementPolicyApprovalRuleArgsDict(TypedDict):
         """

pulumi_azure_native/authorization/v20201001/get_pim_role_eligibility_schedule.py

@@ -0,0 +1,353 @@
+# 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
+
+__all__ = [
+    'GetPimRoleEligibilityScheduleResult',
+    'AwaitableGetPimRoleEligibilityScheduleResult',
+    'get_pim_role_eligibility_schedule',
+    'get_pim_role_eligibility_schedule_output',
+]
+
+@pulumi.output_type
+class GetPimRoleEligibilityScheduleResult:
+    """
+    Role Eligibility schedule request
+    """
+    def __init__(__self__, approval_id=None, condition=None, condition_version=None, created_on=None, expanded_properties=None, id=None, justification=None, name=None, principal_id=None, principal_type=None, request_type=None, requestor_id=None, role_definition_id=None, schedule_info=None, scope=None, status=None, target_role_eligibility_schedule_id=None, target_role_eligibility_schedule_instance_id=None, ticket_info=None, type=None):
+        if approval_id and not isinstance(approval_id, str):
+            raise TypeError("Expected argument 'approval_id' to be a str")
+        pulumi.set(__self__, "approval_id", approval_id)
+        if condition and not isinstance(condition, str):
+            raise TypeError("Expected argument 'condition' to be a str")
+        pulumi.set(__self__, "condition", condition)
+        if condition_version and not isinstance(condition_version, str):
+            raise TypeError("Expected argument 'condition_version' to be a str")
+        pulumi.set(__self__, "condition_version", condition_version)
+        if created_on and not isinstance(created_on, str):
+            raise TypeError("Expected argument 'created_on' to be a str")
+        pulumi.set(__self__, "created_on", created_on)
+        if expanded_properties and not isinstance(expanded_properties, dict):
+            raise TypeError("Expected argument 'expanded_properties' to be a dict")
+        pulumi.set(__self__, "expanded_properties", expanded_properties)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if justification and not isinstance(justification, str):
+            raise TypeError("Expected argument 'justification' to be a str")
+        pulumi.set(__self__, "justification", justification)
+        if name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", name)
+        if principal_id and not isinstance(principal_id, str):
+            raise TypeError("Expected argument 'principal_id' to be a str")
+        pulumi.set(__self__, "principal_id", principal_id)
+        if principal_type and not isinstance(principal_type, str):
+            raise TypeError("Expected argument 'principal_type' to be a str")
+        pulumi.set(__self__, "principal_type", principal_type)
+        if request_type and not isinstance(request_type, str):
+            raise TypeError("Expected argument 'request_type' to be a str")
+        pulumi.set(__self__, "request_type", request_type)
+        if requestor_id and not isinstance(requestor_id, str):
+            raise TypeError("Expected argument 'requestor_id' to be a str")
+        pulumi.set(__self__, "requestor_id", requestor_id)
+        if role_definition_id and not isinstance(role_definition_id, str):
+            raise TypeError("Expected argument 'role_definition_id' to be a str")
+        pulumi.set(__self__, "role_definition_id", role_definition_id)
+        if schedule_info and not isinstance(schedule_info, dict):
+            raise TypeError("Expected argument 'schedule_info' to be a dict")
+        pulumi.set(__self__, "schedule_info", schedule_info)
+        if scope and not isinstance(scope, str):
+            raise TypeError("Expected argument 'scope' to be a str")
+        pulumi.set(__self__, "scope", scope)
+        if status and not isinstance(status, str):
+            raise TypeError("Expected argument 'status' to be a str")
+        pulumi.set(__self__, "status", status)
+        if target_role_eligibility_schedule_id and not isinstance(target_role_eligibility_schedule_id, str):
+            raise TypeError("Expected argument 'target_role_eligibility_schedule_id' to be a str")
+        pulumi.set(__self__, "target_role_eligibility_schedule_id", target_role_eligibility_schedule_id)
+        if target_role_eligibility_schedule_instance_id and not isinstance(target_role_eligibility_schedule_instance_id, str):
+            raise TypeError("Expected argument 'target_role_eligibility_schedule_instance_id' to be a str")
+        pulumi.set(__self__, "target_role_eligibility_schedule_instance_id", target_role_eligibility_schedule_instance_id)
+        if ticket_info and not isinstance(ticket_info, dict):
+            raise TypeError("Expected argument 'ticket_info' to be a dict")
+        pulumi.set(__self__, "ticket_info", ticket_info)
+        if type and not isinstance(type, str):
+            raise TypeError("Expected argument 'type' to be a str")
+        pulumi.set(__self__, "type", type)
+
+    @property
+    @pulumi.getter(name="approvalId")
+    def approval_id(self) -> str:
+        """
+        The approvalId of the role eligibility schedule request.
+        """
+        return pulumi.get(self, "approval_id")
+
+    @property
+    @pulumi.getter
+    def condition(self) -> Optional[str]:
+        """
+        The conditions on the role assignment. This limits the resources it can be assigned to. e.g.: @Resource[Microsoft.Storage/storageAccounts/blobServices/containers:ContainerName] StringEqualsIgnoreCase 'foo_storage_container'
+        """
+        return pulumi.get(self, "condition")
+
+    @property
+    @pulumi.getter(name="conditionVersion")
+    def condition_version(self) -> Optional[str]:
+        """
+        Version of the condition. Currently accepted value is '2.0'
+        """
+        return pulumi.get(self, "condition_version")
+
+    @property
+    @pulumi.getter(name="createdOn")
+    def created_on(self) -> str:
+        """
+        DateTime when role eligibility schedule request was created
+        """
+        return pulumi.get(self, "created_on")
+
+    @property
+    @pulumi.getter(name="expandedProperties")
+    def expanded_properties(self) -> 'outputs.ExpandedPropertiesResponse':
+        """
+        Additional properties of principal, scope and role definition
+        """
+        return pulumi.get(self, "expanded_properties")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The role eligibility schedule request ID.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def justification(self) -> Optional[str]:
+        """
+        Justification for the role eligibility
+        """
+        return pulumi.get(self, "justification")
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The role eligibility schedule request name.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="principalId")
+    def principal_id(self) -> str:
+        """
+        The principal ID.
+        """
+        return pulumi.get(self, "principal_id")
+
+    @property
+    @pulumi.getter(name="principalType")
+    def principal_type(self) -> str:
+        """
+        The principal type of the assigned principal ID.
+        """
+        return pulumi.get(self, "principal_type")
+
+    @property
+    @pulumi.getter(name="requestType")
+    def request_type(self) -> str:
+        """
+        The type of the role assignment schedule request. Eg: SelfActivate, AdminAssign etc
+        """
+        return pulumi.get(self, "request_type")
+
+    @property
+    @pulumi.getter(name="requestorId")
+    def requestor_id(self) -> str:
+        """
+        Id of the user who created this request
+        """
+        return pulumi.get(self, "requestor_id")
+
+    @property
+    @pulumi.getter(name="roleDefinitionId")
+    def role_definition_id(self) -> str:
+        """
+        The role definition ID.
+        """
+        return pulumi.get(self, "role_definition_id")
+
+    @property
+    @pulumi.getter(name="scheduleInfo")
+    def schedule_info(self) -> Optional['outputs.RoleEligibilityScheduleRequestPropertiesResponseScheduleInfo']:
+        """
+        Schedule info of the role eligibility schedule
+        """
+        return pulumi.get(self, "schedule_info")
+
+    @property
+    @pulumi.getter
+    def scope(self) -> str:
+        """
+        The role eligibility schedule request scope.
+        """
+        return pulumi.get(self, "scope")
+
+    @property
+    @pulumi.getter
+    def status(self) -> str:
+        """
+        The status of the role eligibility schedule request.
+        """
+        return pulumi.get(self, "status")
+
+    @property
+    @pulumi.getter(name="targetRoleEligibilityScheduleId")
+    def target_role_eligibility_schedule_id(self) -> Optional[str]:
+        """
+        The resultant role eligibility schedule id or the role eligibility schedule id being updated
+        """
+        return pulumi.get(self, "target_role_eligibility_schedule_id")
+
+    @property
+    @pulumi.getter(name="targetRoleEligibilityScheduleInstanceId")
+    def target_role_eligibility_schedule_instance_id(self) -> Optional[str]:
+        """
+        The role eligibility schedule instance id being updated
+        """
+        return pulumi.get(self, "target_role_eligibility_schedule_instance_id")
+
+    @property
+    @pulumi.getter(name="ticketInfo")
+    def ticket_info(self) -> Optional['outputs.RoleEligibilityScheduleRequestPropertiesResponseTicketInfo']:
+        """
+        Ticket Info of the role eligibility
+        """
+        return pulumi.get(self, "ticket_info")
+
+    @property
+    @pulumi.getter
+    def type(self) -> str:
+        """
+        The role eligibility schedule request type.
+        """
+        return pulumi.get(self, "type")
+
+
+class AwaitableGetPimRoleEligibilityScheduleResult(GetPimRoleEligibilityScheduleResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetPimRoleEligibilityScheduleResult(
+            approval_id=self.approval_id,
+            condition=self.condition,
+            condition_version=self.condition_version,
+            created_on=self.created_on,
+            expanded_properties=self.expanded_properties,
+            id=self.id,
+            justification=self.justification,
+            name=self.name,
+            principal_id=self.principal_id,
+            principal_type=self.principal_type,
+            request_type=self.request_type,
+            requestor_id=self.requestor_id,
+            role_definition_id=self.role_definition_id,
+            schedule_info=self.schedule_info,
+            scope=self.scope,
+            status=self.status,
+            target_role_eligibility_schedule_id=self.target_role_eligibility_schedule_id,
+            target_role_eligibility_schedule_instance_id=self.target_role_eligibility_schedule_instance_id,
+            ticket_info=self.ticket_info,
+            type=self.type)
+
+
+def get_pim_role_eligibility_schedule(role_eligibility_schedule_request_name: Optional[str] = None,
+                                      scope: Optional[str] = None,
+                                      opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetPimRoleEligibilityScheduleResult:
+    """
+    Get the specified role eligibility schedule request.
+
+
+    :param str role_eligibility_schedule_request_name: The name (guid) of the role eligibility schedule request to get.
+    :param str scope: The scope of the role eligibility schedule request.
+    """
+    __args__ = dict()
+    __args__['roleEligibilityScheduleRequestName'] = role_eligibility_schedule_request_name
+    __args__['scope'] = scope
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('azure-native:authorization/v20201001:getPimRoleEligibilitySchedule', __args__, opts=opts, typ=GetPimRoleEligibilityScheduleResult).value
+
+    return AwaitableGetPimRoleEligibilityScheduleResult(
+        approval_id=pulumi.get(__ret__, 'approval_id'),
+        condition=pulumi.get(__ret__, 'condition'),
+        condition_version=pulumi.get(__ret__, 'condition_version'),
+        created_on=pulumi.get(__ret__, 'created_on'),
+        expanded_properties=pulumi.get(__ret__, 'expanded_properties'),
+        id=pulumi.get(__ret__, 'id'),
+        justification=pulumi.get(__ret__, 'justification'),
+        name=pulumi.get(__ret__, 'name'),
+        principal_id=pulumi.get(__ret__, 'principal_id'),
+        principal_type=pulumi.get(__ret__, 'principal_type'),
+        request_type=pulumi.get(__ret__, 'request_type'),
+        requestor_id=pulumi.get(__ret__, 'requestor_id'),
+        role_definition_id=pulumi.get(__ret__, 'role_definition_id'),
+        schedule_info=pulumi.get(__ret__, 'schedule_info'),
+        scope=pulumi.get(__ret__, 'scope'),
+        status=pulumi.get(__ret__, 'status'),
+        target_role_eligibility_schedule_id=pulumi.get(__ret__, 'target_role_eligibility_schedule_id'),
+        target_role_eligibility_schedule_instance_id=pulumi.get(__ret__, 'target_role_eligibility_schedule_instance_id'),
+        ticket_info=pulumi.get(__ret__, 'ticket_info'),
+        type=pulumi.get(__ret__, 'type'))
+def get_pim_role_eligibility_schedule_output(role_eligibility_schedule_request_name: Optional[pulumi.Input[str]] = None,
+                                             scope: Optional[pulumi.Input[str]] = None,
+                                             opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetPimRoleEligibilityScheduleResult]:
+    """
+    Get the specified role eligibility schedule request.
+
+
+    :param str role_eligibility_schedule_request_name: The name (guid) of the role eligibility schedule request to get.
+    :param str scope: The scope of the role eligibility schedule request.
+    """
+    __args__ = dict()
+    __args__['roleEligibilityScheduleRequestName'] = role_eligibility_schedule_request_name
+    __args__['scope'] = scope
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('azure-native:authorization/v20201001:getPimRoleEligibilitySchedule', __args__, opts=opts, typ=GetPimRoleEligibilityScheduleResult)
+    return __ret__.apply(lambda __response__: GetPimRoleEligibilityScheduleResult(
+        approval_id=pulumi.get(__response__, 'approval_id'),
+        condition=pulumi.get(__response__, 'condition'),
+        condition_version=pulumi.get(__response__, 'condition_version'),
+        created_on=pulumi.get(__response__, 'created_on'),
+        expanded_properties=pulumi.get(__response__, 'expanded_properties'),
+        id=pulumi.get(__response__, 'id'),
+        justification=pulumi.get(__response__, 'justification'),
+        name=pulumi.get(__response__, 'name'),
+        principal_id=pulumi.get(__response__, 'principal_id'),
+        principal_type=pulumi.get(__response__, 'principal_type'),
+        request_type=pulumi.get(__response__, 'request_type'),
+        requestor_id=pulumi.get(__response__, 'requestor_id'),
+        role_definition_id=pulumi.get(__response__, 'role_definition_id'),
+        schedule_info=pulumi.get(__response__, 'schedule_info'),
+        scope=pulumi.get(__response__, 'scope'),
+        status=pulumi.get(__response__, 'status'),
+        target_role_eligibility_schedule_id=pulumi.get(__response__, 'target_role_eligibility_schedule_id'),
+        target_role_eligibility_schedule_instance_id=pulumi.get(__response__, 'target_role_eligibility_schedule_instance_id'),
+        ticket_info=pulumi.get(__response__, 'ticket_info'),
+        type=pulumi.get(__response__, 'type')))