Subscription and Features

class SubscriptionsOperations:
    def list_locations(
        self, 
        subscription_id: str, 
        **kwargs
    ) -> Iterable[Location]:
        """
        List available locations for a subscription.
        
        Args:
            subscription_id (str): Subscription ID
            
        Returns:
            Iterable[Location]: Iterator of available locations
        """

    def get(self, subscription_id: str, **kwargs) -> Subscription:
        """
        Get subscription details.
        
        Args:
            subscription_id (str): Subscription ID
            
        Returns:
            Subscription: Subscription information
        """

    def list(self, **kwargs) -> Iterable[Subscription]:
        """
        List all subscriptions for the authenticated user.
        
        Returns:
            Iterable[Subscription]: Iterator of subscriptions
        """

    def check_zone_peers(
        self,
        subscription_id: str,
        parameters: CheckZonePeersRequest,
        **kwargs
    ) -> CheckZonePeersResult:
        """
        Check availability zone peers for a subscription.
        
        Args:
            subscription_id (str): Subscription ID
            parameters (CheckZonePeersRequest): Zone peer check parameters
            
        Returns:
            CheckZonePeersResult: Zone peer information
        """

class TenantsOperations:
    def list(self, **kwargs) -> Iterable[TenantIdDescription]:
        """
        List tenants for the authenticated user.
        
        Returns:
            Iterable[TenantIdDescription]: Iterator of tenant information
        """

class FeaturesOperations:
    def list(
        self, 
        resource_provider_namespace: str, 
        **kwargs
    ) -> Iterable[FeatureResult]:
        """
        List features for a resource provider.
        
        Args:
            resource_provider_namespace (str): Resource provider namespace
            
        Returns:
            Iterable[FeatureResult]: Iterator of features
        """

    def list_all(self, **kwargs) -> Iterable[FeatureResult]:
        """
        List all features across all resource providers.
        
        Returns:
            Iterable[FeatureResult]: Iterator of all features
        """

    def get(
        self,
        resource_provider_namespace: str,
        feature_name: str,
        **kwargs
    ) -> FeatureResult:
        """
        Get feature information.
        
        Args:
            resource_provider_namespace (str): Resource provider namespace
            feature_name (str): Feature name
            
        Returns:
            FeatureResult: Feature details
        """

    def register(
        self,
        resource_provider_namespace: str,
        feature_name: str,
        **kwargs
    ) -> FeatureResult:
        """
        Register a feature for the subscription.
        
        Args:
            resource_provider_namespace (str): Resource provider namespace
            feature_name (str): Feature name
            
        Returns:
            FeatureResult: Registration result
        """

    def unregister(
        self,
        resource_provider_namespace: str,
        feature_name: str,
        **kwargs
    ) -> FeatureResult:
        """
        Unregister a feature for the subscription.
        
        Returns:
            FeatureResult: Unregistration result
        """

class SubscriptionFeatureRegistrationsOperations:
    def get(
        self,
        provider_namespace: str,
        feature_name: str,
        **kwargs
    ) -> SubscriptionFeatureRegistration:
        """
        Get subscription feature registration.
        
        Args:
            provider_namespace (str): Provider namespace
            feature_name (str): Feature name
            
        Returns:
            SubscriptionFeatureRegistration: Feature registration details
        """

    def create_or_update(
        self,
        provider_namespace: str,
        feature_name: str,
        **kwargs
    ) -> SubscriptionFeatureRegistration:
        """
        Create or update subscription feature registration.
        
        Args:
            provider_namespace (str): Provider namespace
            feature_name (str): Feature name
            
        Returns:
            SubscriptionFeatureRegistration: Registration result
        """

    def delete(
        self,
        provider_namespace: str,
        feature_name: str,
        **kwargs
    ) -> None:
        """Delete subscription feature registration."""

    def list_all_by_subscription(
        self, 
        **kwargs
    ) -> Iterable[SubscriptionFeatureRegistration]:
        """
        List all feature registrations for the subscription.
        
        Returns:
            Iterable[SubscriptionFeatureRegistration]: Iterator of registrations
        """

    def list_by_subscription(
        self,
        provider_namespace: str,
        **kwargs
    ) -> Iterable[SubscriptionFeatureRegistration]:
        """
        List feature registrations for a provider.
        
        Args:
            provider_namespace (str): Provider namespace
            
        Returns:
            Iterable[SubscriptionFeatureRegistration]: Iterator of registrations
        """

class Subscription:
    """Subscription information."""
    id: str
    subscription_id: str
    tenant_id: str
    display_name: str
    state: SubscriptionState
    subscription_policies: SubscriptionPolicies
    authorization_source: str
    managed_by_tenants: List[ManagedByTenant]
    tags: Dict[str, str]

class SubscriptionPolicies:
    """Subscription policies."""
    location_placement_id: str
    quota_id: str
    spending_limit: SpendingLimit

class Location:
    """Azure location information."""
    id: str
    subscription_id: str
    name: str
    type: str
    display_name: str
    latitude: str
    longitude: str
    regional_display_name: str
    metadata: LocationMetadata
    availability_zone_mappings: List[AvailabilityZoneMapping]

class TenantIdDescription:
    """Tenant information."""
    id: str
    tenant_id: str
    display_name: str
    domains: List[str]
    country: str
    country_code: str
    tenant_category: TenantCategory
    default_domain: str
    tenant_type: str

class FeatureResult:
    """Feature information."""
    name: str
    properties: FeatureProperties
    id: str
    type: str

class FeatureProperties:
    """Feature properties."""
    state: str
    display_name: str
    description: str

class SubscriptionFeatureRegistration:
    """Subscription feature registration."""
    id: str
    name: str
    type: str
    properties: SubscriptionFeatureRegistrationProperties

class SubscriptionFeatureRegistrationProperties:
    """Subscription feature registration properties."""
    tenant_id: str
    subscription_id: str
    feature_name: str
    display_name: str
    provider_namespace: str
    state: SubscriptionFeatureRegistrationState
    authorization_profile: AuthorizationProfile
    metadata: Dict[str, str]
    should_feature_display_in_portal: bool
    description: str
    documentation_link: str
    approval_type: SubscriptionFeatureRegistrationApprovalType

class AuthorizationProfile:
    """Authorization profile for feature registration."""
    requested_time: datetime
    requester: str
    requester_object_id: str
    approved_time: datetime
    approver: str
    approval_type: SubscriptionFeatureRegistrationApprovalType

class CheckZonePeersRequest:
    """Zone peers check request."""
    location: str
    subscription_ids: List[str]

class CheckZonePeersResult:
    """Zone peers check result."""
    subscription_id: str
    location: str
    availability_zone_peers: List[AvailabilityZonePeers]

class AvailabilityZonePeers:
    """Availability zone peer information."""
    availability_zone: str
    peers: List[Peer]

class SubscriptionState(str, Enum):
    """Subscription states."""
    ENABLED = "Enabled"
    WARNED = "Warned"
    PAST_DUE = "PastDue"
    DISABLED = "Disabled"
    DELETED = "Deleted"

class SpendingLimit(str, Enum):
    """Spending limit states."""
    ON = "On"
    OFF = "Off"
    CURRENT_PERIOD_OFF = "CurrentPeriodOff"

class TenantCategory(str, Enum):
    """Tenant categories."""
    HOME = "Home"
    PROJECTED_BY = "ProjectedBy"
    MANAGED_BY = "ManagedBy"

class SubscriptionFeatureRegistrationState(str, Enum):
    """Feature registration states."""
    NOT_SPECIFIED = "NotSpecified"
    NOT_REGISTERED = "NotRegistered"
    PENDING = "Pending"
    REGISTERING = "Registering"  
    REGISTERED = "Registered"
    UNREGISTERING = "Unregistering"
    UNREGISTERED = "Unregistered"

class SubscriptionFeatureRegistrationApprovalType(str, Enum):
    """Feature registration approval types."""
    NOT_SPECIFIED = "NotSpecified"
    REQUIRED = "Required"
    AUTO_APPROVAL = "AutoApproval"

from azure.identity import DefaultAzureCredential
from azure.mgmt.resource import SubscriptionClient

# Create subscription client (no subscription_id needed)
credential = DefaultAzureCredential()
sub_client = SubscriptionClient(credential=credential)

# List all accessible subscriptions
print("Available subscriptions:")
for subscription in sub_client.subscriptions.list():
    print(f"  {subscription.display_name}: {subscription.subscription_id}")

# Get details for a specific subscription
subscription = sub_client.subscriptions.get("your-subscription-id")
print(f"Subscription: {subscription.display_name}")
print(f"State: {subscription.state}")
print(f"Tenant ID: {subscription.tenant_id}")

# List available locations
locations = sub_client.subscriptions.list_locations("your-subscription-id")
for location in locations:
    print(f"Location: {location.display_name} ({location.name})")

from azure.identity import DefaultAzureCredential
from azure.mgmt.resource import FeatureClient

credential = DefaultAzureCredential()
feature_client = FeatureClient(
    credential=credential,
    subscription_id="your-subscription-id"
)

# List all features for a resource provider
features = feature_client.features.list("Microsoft.Compute")
for feature in features:
    print(f"Feature: {feature.name}")
    print(f"  State: {feature.properties.state}")
    print(f"  Display Name: {feature.properties.display_name}")

# Register a preview feature
registration = feature_client.features.register(
    resource_provider_namespace="Microsoft.Compute",
    feature_name="SomePreviewFeature"
)
print(f"Registration state: {registration.properties.state}")

# Check feature registration status
feature = feature_client.features.get(
    resource_provider_namespace="Microsoft.Compute",
    feature_name="SomePreviewFeature"
)
print(f"Current state: {feature.properties.state}")

# List all feature registrations for the subscription
registrations = feature_client.subscription_feature_registrations.list_all_by_subscription()
for registration in registrations:
    print(f"Feature: {registration.properties.feature_name}")
    print(f"  Provider: {registration.properties.provider_namespace}")
    print(f"  State: {registration.properties.state}")
    print(f"  Approval Type: {registration.properties.approval_type}")

# Create a subscription feature registration
registration = feature_client.subscription_feature_registrations.create_or_update(
    provider_namespace="Microsoft.Storage",
    feature_name="AllowBlobPublicAccess"
)