# 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 builtins as _builtins
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

__all__ = [
    'LicensingSubscriptionSubscriptionsBindItemArgs',
    'LicensingSubscriptionSubscriptionsBindItemArgsDict',
    'LicensingSubscriptionSubscriptionsBindItemInsufficientEntitlementArgs',
    'LicensingSubscriptionSubscriptionsBindItemInsufficientEntitlementArgsDict',
    'LicensingSubscriptionSubscriptionsBindItemNetworkArgs',
    'LicensingSubscriptionSubscriptionsBindItemNetworkArgsDict',
    'LicensingSubscriptionSubscriptionsBindParametersArgs',
    'LicensingSubscriptionSubscriptionsBindParametersArgsDict',
    'LicensingSubscriptionSubscriptionsClaimItemArgs',
    'LicensingSubscriptionSubscriptionsClaimItemArgsDict',
    'LicensingSubscriptionSubscriptionsClaimItemCountsArgs',
    'LicensingSubscriptionSubscriptionsClaimItemCountsArgsDict',
    'LicensingSubscriptionSubscriptionsClaimItemCountsSeatsArgs',
    'LicensingSubscriptionSubscriptionsClaimItemCountsSeatsArgsDict',
    'LicensingSubscriptionSubscriptionsClaimItemEntitlementArgs',
    'LicensingSubscriptionSubscriptionsClaimItemEntitlementArgsDict',
    'LicensingSubscriptionSubscriptionsClaimItemEntitlementSeatsArgs',
    'LicensingSubscriptionSubscriptionsClaimItemEntitlementSeatsArgsDict',
    'LicensingSubscriptionSubscriptionsClaimKeyValidateItemArgs',
    'LicensingSubscriptionSubscriptionsClaimKeyValidateItemArgsDict',
    'LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsArgs',
    'LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsArgsDict',
    'LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsSeatsArgs',
    'LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsSeatsArgsDict',
    'LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementArgs',
    'LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementArgsDict',
    'LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementSeatsArgs',
    'LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementSeatsArgsDict',
    'LicensingSubscriptionSubscriptionsClaimKeyValidateParametersArgs',
    'LicensingSubscriptionSubscriptionsClaimKeyValidateParametersArgsDict',
    'LicensingSubscriptionSubscriptionsClaimParametersArgs',
    'LicensingSubscriptionSubscriptionsClaimParametersArgsDict',
]

MYPY = False

if not MYPY:
    class LicensingSubscriptionSubscriptionsBindItemArgsDict(TypedDict):
        errors: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Array of errors if failed
        """
        insufficient_entitlements: NotRequired[pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsBindItemInsufficientEntitlementArgsDict']]]]
        """
        A list of entitlements required to successfully bind the networks to the subscription
        """
        networks: NotRequired[pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsBindItemNetworkArgsDict']]]]
        """
        Unbound networks
        """
        subscription_id: NotRequired[pulumi.Input[_builtins.str]]
        """
        Subscription ID
        """
elif False:
    LicensingSubscriptionSubscriptionsBindItemArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LicensingSubscriptionSubscriptionsBindItemArgs:
    def __init__(__self__, *,
                 errors: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 insufficient_entitlements: Optional[pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsBindItemInsufficientEntitlementArgs']]]] = None,
                 networks: Optional[pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsBindItemNetworkArgs']]]] = None,
                 subscription_id: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] errors: Array of errors if failed
        :param pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsBindItemInsufficientEntitlementArgs']]] insufficient_entitlements: A list of entitlements required to successfully bind the networks to the subscription
        :param pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsBindItemNetworkArgs']]] networks: Unbound networks
        :param pulumi.Input[_builtins.str] subscription_id: Subscription ID
        """
        if errors is not None:
            pulumi.set(__self__, "errors", errors)
        if insufficient_entitlements is not None:
            pulumi.set(__self__, "insufficient_entitlements", insufficient_entitlements)
        if networks is not None:
            pulumi.set(__self__, "networks", networks)
        if subscription_id is not None:
            pulumi.set(__self__, "subscription_id", subscription_id)

    @_builtins.property
    @pulumi.getter
    def errors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Array of errors if failed
        """
        return pulumi.get(self, "errors")

    @errors.setter
    def errors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "errors", value)

    @_builtins.property
    @pulumi.getter(name="insufficientEntitlements")
    def insufficient_entitlements(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsBindItemInsufficientEntitlementArgs']]]]:
        """
        A list of entitlements required to successfully bind the networks to the subscription
        """
        return pulumi.get(self, "insufficient_entitlements")

    @insufficient_entitlements.setter
    def insufficient_entitlements(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsBindItemInsufficientEntitlementArgs']]]]):
        pulumi.set(self, "insufficient_entitlements", value)

    @_builtins.property
    @pulumi.getter
    def networks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsBindItemNetworkArgs']]]]:
        """
        Unbound networks
        """
        return pulumi.get(self, "networks")

    @networks.setter
    def networks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsBindItemNetworkArgs']]]]):
        pulumi.set(self, "networks", value)

    @_builtins.property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Subscription ID
        """
        return pulumi.get(self, "subscription_id")

    @subscription_id.setter
    def subscription_id(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "subscription_id", value)


if not MYPY:
    class LicensingSubscriptionSubscriptionsBindItemInsufficientEntitlementArgsDict(TypedDict):
        quantity: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number required
        """
        sku: NotRequired[pulumi.Input[_builtins.str]]
        """
        SKU of the required product
        """
elif False:
    LicensingSubscriptionSubscriptionsBindItemInsufficientEntitlementArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LicensingSubscriptionSubscriptionsBindItemInsufficientEntitlementArgs:
    def __init__(__self__, *,
                 quantity: Optional[pulumi.Input[_builtins.int]] = None,
                 sku: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.int] quantity: Number required
        :param pulumi.Input[_builtins.str] sku: SKU of the required product
        """
        if quantity is not None:
            pulumi.set(__self__, "quantity", quantity)
        if sku is not None:
            pulumi.set(__self__, "sku", sku)

    @_builtins.property
    @pulumi.getter
    def quantity(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number required
        """
        return pulumi.get(self, "quantity")

    @quantity.setter
    def quantity(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "quantity", value)

    @_builtins.property
    @pulumi.getter
    def sku(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        SKU of the required product
        """
        return pulumi.get(self, "sku")

    @sku.setter
    def sku(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "sku", value)


if not MYPY:
    class LicensingSubscriptionSubscriptionsBindItemNetworkArgsDict(TypedDict):
        id: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network ID
        """
        name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network name
        """
elif False:
    LicensingSubscriptionSubscriptionsBindItemNetworkArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LicensingSubscriptionSubscriptionsBindItemNetworkArgs:
    def __init__(__self__, *,
                 id: Optional[pulumi.Input[_builtins.str]] = None,
                 name: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] id: Network ID
        :param pulumi.Input[_builtins.str] name: Network name
        """
        if id is not None:
            pulumi.set(__self__, "id", id)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Network ID
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "id", value)

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Network name
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "name", value)


if not MYPY:
    class LicensingSubscriptionSubscriptionsBindParametersArgsDict(TypedDict):
        network_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        List of network ids to bind to the subscription
        """
elif False:
    LicensingSubscriptionSubscriptionsBindParametersArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LicensingSubscriptionSubscriptionsBindParametersArgs:
    def __init__(__self__, *,
                 network_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] network_ids: List of network ids to bind to the subscription
        """
        if network_ids is not None:
            pulumi.set(__self__, "network_ids", network_ids)

    @_builtins.property
    @pulumi.getter(name="networkIds")
    def network_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        List of network ids to bind to the subscription
        """
        return pulumi.get(self, "network_ids")

    @network_ids.setter
    def network_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "network_ids", value)


if not MYPY:
    class LicensingSubscriptionSubscriptionsClaimItemArgsDict(TypedDict):
        counts: NotRequired[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemCountsArgsDict']]
        """
        Numeric breakdown of network and entitlement counts
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Subscription description
        """
        end_date: NotRequired[pulumi.Input[_builtins.str]]
        """
        Subscription expiration date
        """
        entitlements: NotRequired[pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemEntitlementArgsDict']]]]
        """
        Entitlement info
        """
        name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Subscription name
        """
        product_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Products the subscription has entitlements for
        """
        start_date: NotRequired[pulumi.Input[_builtins.str]]
        """
        Subscription start date
        """
        status: NotRequired[pulumi.Input[_builtins.str]]
        """
        Subscription status
        """
        subscription_id: NotRequired[pulumi.Input[_builtins.str]]
        """
        Subscription's ID
        """
        web_order_id: NotRequired[pulumi.Input[_builtins.str]]
        """
        Web order id
        """
elif False:
    LicensingSubscriptionSubscriptionsClaimItemArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LicensingSubscriptionSubscriptionsClaimItemArgs:
    def __init__(__self__, *,
                 counts: Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemCountsArgs']] = None,
                 description: Optional[pulumi.Input[_builtins.str]] = None,
                 end_date: Optional[pulumi.Input[_builtins.str]] = None,
                 entitlements: Optional[pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemEntitlementArgs']]]] = None,
                 name: Optional[pulumi.Input[_builtins.str]] = None,
                 product_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 start_date: Optional[pulumi.Input[_builtins.str]] = None,
                 status: Optional[pulumi.Input[_builtins.str]] = None,
                 subscription_id: Optional[pulumi.Input[_builtins.str]] = None,
                 web_order_id: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemCountsArgs'] counts: Numeric breakdown of network and entitlement counts
        :param pulumi.Input[_builtins.str] description: Subscription description
        :param pulumi.Input[_builtins.str] end_date: Subscription expiration date
        :param pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemEntitlementArgs']]] entitlements: Entitlement info
        :param pulumi.Input[_builtins.str] name: Subscription name
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] product_types: Products the subscription has entitlements for
        :param pulumi.Input[_builtins.str] start_date: Subscription start date
        :param pulumi.Input[_builtins.str] status: Subscription status
        :param pulumi.Input[_builtins.str] subscription_id: Subscription's ID
        :param pulumi.Input[_builtins.str] web_order_id: Web order id
        """
        if counts is not None:
            pulumi.set(__self__, "counts", counts)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if end_date is not None:
            pulumi.set(__self__, "end_date", end_date)
        if entitlements is not None:
            pulumi.set(__self__, "entitlements", entitlements)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if product_types is not None:
            pulumi.set(__self__, "product_types", product_types)
        if start_date is not None:
            pulumi.set(__self__, "start_date", start_date)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if subscription_id is not None:
            pulumi.set(__self__, "subscription_id", subscription_id)
        if web_order_id is not None:
            pulumi.set(__self__, "web_order_id", web_order_id)

    @_builtins.property
    @pulumi.getter
    def counts(self) -> Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemCountsArgs']]:
        """
        Numeric breakdown of network and entitlement counts
        """
        return pulumi.get(self, "counts")

    @counts.setter
    def counts(self, value: Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemCountsArgs']]):
        pulumi.set(self, "counts", value)

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Subscription description
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "description", value)

    @_builtins.property
    @pulumi.getter(name="endDate")
    def end_date(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Subscription expiration date
        """
        return pulumi.get(self, "end_date")

    @end_date.setter
    def end_date(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "end_date", value)

    @_builtins.property
    @pulumi.getter
    def entitlements(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemEntitlementArgs']]]]:
        """
        Entitlement info
        """
        return pulumi.get(self, "entitlements")

    @entitlements.setter
    def entitlements(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemEntitlementArgs']]]]):
        pulumi.set(self, "entitlements", value)

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Subscription name
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "name", value)

    @_builtins.property
    @pulumi.getter(name="productTypes")
    def product_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Products the subscription has entitlements for
        """
        return pulumi.get(self, "product_types")

    @product_types.setter
    def product_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "product_types", value)

    @_builtins.property
    @pulumi.getter(name="startDate")
    def start_date(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Subscription start date
        """
        return pulumi.get(self, "start_date")

    @start_date.setter
    def start_date(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "start_date", value)

    @_builtins.property
    @pulumi.getter
    def status(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Subscription status
        """
        return pulumi.get(self, "status")

    @status.setter
    def status(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "status", value)

    @_builtins.property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Subscription's ID
        """
        return pulumi.get(self, "subscription_id")

    @subscription_id.setter
    def subscription_id(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "subscription_id", value)

    @_builtins.property
    @pulumi.getter(name="webOrderId")
    def web_order_id(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Web order id
        """
        return pulumi.get(self, "web_order_id")

    @web_order_id.setter
    def web_order_id(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "web_order_id", value)


if not MYPY:
    class LicensingSubscriptionSubscriptionsClaimItemCountsArgsDict(TypedDict):
        networks: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of networks bound to this subscription
        """
        seats: NotRequired[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemCountsSeatsArgsDict']]
        """
        Seat distribution
        """
elif False:
    LicensingSubscriptionSubscriptionsClaimItemCountsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LicensingSubscriptionSubscriptionsClaimItemCountsArgs:
    def __init__(__self__, *,
                 networks: Optional[pulumi.Input[_builtins.int]] = None,
                 seats: Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemCountsSeatsArgs']] = None):
        """
        :param pulumi.Input[_builtins.int] networks: Number of networks bound to this subscription
        :param pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemCountsSeatsArgs'] seats: Seat distribution
        """
        if networks is not None:
            pulumi.set(__self__, "networks", networks)
        if seats is not None:
            pulumi.set(__self__, "seats", seats)

    @_builtins.property
    @pulumi.getter
    def networks(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of networks bound to this subscription
        """
        return pulumi.get(self, "networks")

    @networks.setter
    def networks(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "networks", value)

    @_builtins.property
    @pulumi.getter
    def seats(self) -> Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemCountsSeatsArgs']]:
        """
        Seat distribution
        """
        return pulumi.get(self, "seats")

    @seats.setter
    def seats(self, value: Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemCountsSeatsArgs']]):
        pulumi.set(self, "seats", value)


if not MYPY:
    class LicensingSubscriptionSubscriptionsClaimItemCountsSeatsArgsDict(TypedDict):
        assigned: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of seats in use
        """
        available: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of seats available for use
        """
        limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        Total number of seats provided by this subscription
        """
elif False:
    LicensingSubscriptionSubscriptionsClaimItemCountsSeatsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LicensingSubscriptionSubscriptionsClaimItemCountsSeatsArgs:
    def __init__(__self__, *,
                 assigned: Optional[pulumi.Input[_builtins.int]] = None,
                 available: Optional[pulumi.Input[_builtins.int]] = None,
                 limit: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.int] assigned: Number of seats in use
        :param pulumi.Input[_builtins.int] available: Number of seats available for use
        :param pulumi.Input[_builtins.int] limit: Total number of seats provided by this subscription
        """
        if assigned is not None:
            pulumi.set(__self__, "assigned", assigned)
        if available is not None:
            pulumi.set(__self__, "available", available)
        if limit is not None:
            pulumi.set(__self__, "limit", limit)

    @_builtins.property
    @pulumi.getter
    def assigned(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of seats in use
        """
        return pulumi.get(self, "assigned")

    @assigned.setter
    def assigned(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "assigned", value)

    @_builtins.property
    @pulumi.getter
    def available(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of seats available for use
        """
        return pulumi.get(self, "available")

    @available.setter
    def available(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "available", value)

    @_builtins.property
    @pulumi.getter
    def limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Total number of seats provided by this subscription
        """
        return pulumi.get(self, "limit")

    @limit.setter
    def limit(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "limit", value)


if not MYPY:
    class LicensingSubscriptionSubscriptionsClaimItemEntitlementArgsDict(TypedDict):
        seats: NotRequired[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemEntitlementSeatsArgsDict']]
        """
        Seat distribution
        """
        sku: NotRequired[pulumi.Input[_builtins.str]]
        """
        SKU of the required product
        """
elif False:
    LicensingSubscriptionSubscriptionsClaimItemEntitlementArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LicensingSubscriptionSubscriptionsClaimItemEntitlementArgs:
    def __init__(__self__, *,
                 seats: Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemEntitlementSeatsArgs']] = None,
                 sku: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemEntitlementSeatsArgs'] seats: Seat distribution
        :param pulumi.Input[_builtins.str] sku: SKU of the required product
        """
        if seats is not None:
            pulumi.set(__self__, "seats", seats)
        if sku is not None:
            pulumi.set(__self__, "sku", sku)

    @_builtins.property
    @pulumi.getter
    def seats(self) -> Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemEntitlementSeatsArgs']]:
        """
        Seat distribution
        """
        return pulumi.get(self, "seats")

    @seats.setter
    def seats(self, value: Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimItemEntitlementSeatsArgs']]):
        pulumi.set(self, "seats", value)

    @_builtins.property
    @pulumi.getter
    def sku(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        SKU of the required product
        """
        return pulumi.get(self, "sku")

    @sku.setter
    def sku(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "sku", value)


if not MYPY:
    class LicensingSubscriptionSubscriptionsClaimItemEntitlementSeatsArgsDict(TypedDict):
        assigned: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of seats in use
        """
        available: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of seats available for use
        """
        limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        Total number of seats provided by this subscription for this sku
        """
elif False:
    LicensingSubscriptionSubscriptionsClaimItemEntitlementSeatsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LicensingSubscriptionSubscriptionsClaimItemEntitlementSeatsArgs:
    def __init__(__self__, *,
                 assigned: Optional[pulumi.Input[_builtins.int]] = None,
                 available: Optional[pulumi.Input[_builtins.int]] = None,
                 limit: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.int] assigned: Number of seats in use
        :param pulumi.Input[_builtins.int] available: Number of seats available for use
        :param pulumi.Input[_builtins.int] limit: Total number of seats provided by this subscription for this sku
        """
        if assigned is not None:
            pulumi.set(__self__, "assigned", assigned)
        if available is not None:
            pulumi.set(__self__, "available", available)
        if limit is not None:
            pulumi.set(__self__, "limit", limit)

    @_builtins.property
    @pulumi.getter
    def assigned(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of seats in use
        """
        return pulumi.get(self, "assigned")

    @assigned.setter
    def assigned(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "assigned", value)

    @_builtins.property
    @pulumi.getter
    def available(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of seats available for use
        """
        return pulumi.get(self, "available")

    @available.setter
    def available(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "available", value)

    @_builtins.property
    @pulumi.getter
    def limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Total number of seats provided by this subscription for this sku
        """
        return pulumi.get(self, "limit")

    @limit.setter
    def limit(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "limit", value)


if not MYPY:
    class LicensingSubscriptionSubscriptionsClaimKeyValidateItemArgsDict(TypedDict):
        counts: NotRequired[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsArgsDict']]
        """
        Numeric breakdown of network and entitlement counts
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Subscription description
        """
        end_date: NotRequired[pulumi.Input[_builtins.str]]
        """
        Subscription expiration date
        """
        entitlements: NotRequired[pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementArgsDict']]]]
        """
        Entitlement info
        """
        name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Subscription name
        """
        product_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Products the subscription has entitlements for
        """
        start_date: NotRequired[pulumi.Input[_builtins.str]]
        """
        Subscription start date
        """
        status: NotRequired[pulumi.Input[_builtins.str]]
        """
        Subscription status
        """
        subscription_id: NotRequired[pulumi.Input[_builtins.str]]
        """
        Subscription's ID
        """
        web_order_id: NotRequired[pulumi.Input[_builtins.str]]
        """
        Web order id
        """
elif False:
    LicensingSubscriptionSubscriptionsClaimKeyValidateItemArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LicensingSubscriptionSubscriptionsClaimKeyValidateItemArgs:
    def __init__(__self__, *,
                 counts: Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsArgs']] = None,
                 description: Optional[pulumi.Input[_builtins.str]] = None,
                 end_date: Optional[pulumi.Input[_builtins.str]] = None,
                 entitlements: Optional[pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementArgs']]]] = None,
                 name: Optional[pulumi.Input[_builtins.str]] = None,
                 product_types: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 start_date: Optional[pulumi.Input[_builtins.str]] = None,
                 status: Optional[pulumi.Input[_builtins.str]] = None,
                 subscription_id: Optional[pulumi.Input[_builtins.str]] = None,
                 web_order_id: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsArgs'] counts: Numeric breakdown of network and entitlement counts
        :param pulumi.Input[_builtins.str] description: Subscription description
        :param pulumi.Input[_builtins.str] end_date: Subscription expiration date
        :param pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementArgs']]] entitlements: Entitlement info
        :param pulumi.Input[_builtins.str] name: Subscription name
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] product_types: Products the subscription has entitlements for
        :param pulumi.Input[_builtins.str] start_date: Subscription start date
        :param pulumi.Input[_builtins.str] status: Subscription status
        :param pulumi.Input[_builtins.str] subscription_id: Subscription's ID
        :param pulumi.Input[_builtins.str] web_order_id: Web order id
        """
        if counts is not None:
            pulumi.set(__self__, "counts", counts)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if end_date is not None:
            pulumi.set(__self__, "end_date", end_date)
        if entitlements is not None:
            pulumi.set(__self__, "entitlements", entitlements)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if product_types is not None:
            pulumi.set(__self__, "product_types", product_types)
        if start_date is not None:
            pulumi.set(__self__, "start_date", start_date)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if subscription_id is not None:
            pulumi.set(__self__, "subscription_id", subscription_id)
        if web_order_id is not None:
            pulumi.set(__self__, "web_order_id", web_order_id)

    @_builtins.property
    @pulumi.getter
    def counts(self) -> Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsArgs']]:
        """
        Numeric breakdown of network and entitlement counts
        """
        return pulumi.get(self, "counts")

    @counts.setter
    def counts(self, value: Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsArgs']]):
        pulumi.set(self, "counts", value)

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Subscription description
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "description", value)

    @_builtins.property
    @pulumi.getter(name="endDate")
    def end_date(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Subscription expiration date
        """
        return pulumi.get(self, "end_date")

    @end_date.setter
    def end_date(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "end_date", value)

    @_builtins.property
    @pulumi.getter
    def entitlements(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementArgs']]]]:
        """
        Entitlement info
        """
        return pulumi.get(self, "entitlements")

    @entitlements.setter
    def entitlements(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementArgs']]]]):
        pulumi.set(self, "entitlements", value)

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Subscription name
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "name", value)

    @_builtins.property
    @pulumi.getter(name="productTypes")
    def product_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Products the subscription has entitlements for
        """
        return pulumi.get(self, "product_types")

    @product_types.setter
    def product_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "product_types", value)

    @_builtins.property
    @pulumi.getter(name="startDate")
    def start_date(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Subscription start date
        """
        return pulumi.get(self, "start_date")

    @start_date.setter
    def start_date(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "start_date", value)

    @_builtins.property
    @pulumi.getter
    def status(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Subscription status
        """
        return pulumi.get(self, "status")

    @status.setter
    def status(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "status", value)

    @_builtins.property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Subscription's ID
        """
        return pulumi.get(self, "subscription_id")

    @subscription_id.setter
    def subscription_id(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "subscription_id", value)

    @_builtins.property
    @pulumi.getter(name="webOrderId")
    def web_order_id(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Web order id
        """
        return pulumi.get(self, "web_order_id")

    @web_order_id.setter
    def web_order_id(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "web_order_id", value)


if not MYPY:
    class LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsArgsDict(TypedDict):
        networks: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of networks bound to this subscription
        """
        seats: NotRequired[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsSeatsArgsDict']]
        """
        Seat distribution
        """
elif False:
    LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsArgs:
    def __init__(__self__, *,
                 networks: Optional[pulumi.Input[_builtins.int]] = None,
                 seats: Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsSeatsArgs']] = None):
        """
        :param pulumi.Input[_builtins.int] networks: Number of networks bound to this subscription
        :param pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsSeatsArgs'] seats: Seat distribution
        """
        if networks is not None:
            pulumi.set(__self__, "networks", networks)
        if seats is not None:
            pulumi.set(__self__, "seats", seats)

    @_builtins.property
    @pulumi.getter
    def networks(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of networks bound to this subscription
        """
        return pulumi.get(self, "networks")

    @networks.setter
    def networks(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "networks", value)

    @_builtins.property
    @pulumi.getter
    def seats(self) -> Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsSeatsArgs']]:
        """
        Seat distribution
        """
        return pulumi.get(self, "seats")

    @seats.setter
    def seats(self, value: Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsSeatsArgs']]):
        pulumi.set(self, "seats", value)


if not MYPY:
    class LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsSeatsArgsDict(TypedDict):
        assigned: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of seats in use
        """
        available: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of seats available for use
        """
        limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        Total number of seats provided by this subscription
        """
elif False:
    LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsSeatsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LicensingSubscriptionSubscriptionsClaimKeyValidateItemCountsSeatsArgs:
    def __init__(__self__, *,
                 assigned: Optional[pulumi.Input[_builtins.int]] = None,
                 available: Optional[pulumi.Input[_builtins.int]] = None,
                 limit: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.int] assigned: Number of seats in use
        :param pulumi.Input[_builtins.int] available: Number of seats available for use
        :param pulumi.Input[_builtins.int] limit: Total number of seats provided by this subscription
        """
        if assigned is not None:
            pulumi.set(__self__, "assigned", assigned)
        if available is not None:
            pulumi.set(__self__, "available", available)
        if limit is not None:
            pulumi.set(__self__, "limit", limit)

    @_builtins.property
    @pulumi.getter
    def assigned(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of seats in use
        """
        return pulumi.get(self, "assigned")

    @assigned.setter
    def assigned(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "assigned", value)

    @_builtins.property
    @pulumi.getter
    def available(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of seats available for use
        """
        return pulumi.get(self, "available")

    @available.setter
    def available(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "available", value)

    @_builtins.property
    @pulumi.getter
    def limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Total number of seats provided by this subscription
        """
        return pulumi.get(self, "limit")

    @limit.setter
    def limit(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "limit", value)


if not MYPY:
    class LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementArgsDict(TypedDict):
        seats: NotRequired[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementSeatsArgsDict']]
        """
        Seat distribution
        """
        sku: NotRequired[pulumi.Input[_builtins.str]]
        """
        SKU of the required product
        """
elif False:
    LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementArgs:
    def __init__(__self__, *,
                 seats: Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementSeatsArgs']] = None,
                 sku: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementSeatsArgs'] seats: Seat distribution
        :param pulumi.Input[_builtins.str] sku: SKU of the required product
        """
        if seats is not None:
            pulumi.set(__self__, "seats", seats)
        if sku is not None:
            pulumi.set(__self__, "sku", sku)

    @_builtins.property
    @pulumi.getter
    def seats(self) -> Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementSeatsArgs']]:
        """
        Seat distribution
        """
        return pulumi.get(self, "seats")

    @seats.setter
    def seats(self, value: Optional[pulumi.Input['LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementSeatsArgs']]):
        pulumi.set(self, "seats", value)

    @_builtins.property
    @pulumi.getter
    def sku(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        SKU of the required product
        """
        return pulumi.get(self, "sku")

    @sku.setter
    def sku(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "sku", value)


if not MYPY:
    class LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementSeatsArgsDict(TypedDict):
        assigned: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of seats in use
        """
        available: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of seats available for use
        """
        limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        Total number of seats provided by this subscription for this sku
        """
elif False:
    LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementSeatsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LicensingSubscriptionSubscriptionsClaimKeyValidateItemEntitlementSeatsArgs:
    def __init__(__self__, *,
                 assigned: Optional[pulumi.Input[_builtins.int]] = None,
                 available: Optional[pulumi.Input[_builtins.int]] = None,
                 limit: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.int] assigned: Number of seats in use
        :param pulumi.Input[_builtins.int] available: Number of seats available for use
        :param pulumi.Input[_builtins.int] limit: Total number of seats provided by this subscription for this sku
        """
        if assigned is not None:
            pulumi.set(__self__, "assigned", assigned)
        if available is not None:
            pulumi.set(__self__, "available", available)
        if limit is not None:
            pulumi.set(__self__, "limit", limit)

    @_builtins.property
    @pulumi.getter
    def assigned(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of seats in use
        """
        return pulumi.get(self, "assigned")

    @assigned.setter
    def assigned(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "assigned", value)

    @_builtins.property
    @pulumi.getter
    def available(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of seats available for use
        """
        return pulumi.get(self, "available")

    @available.setter
    def available(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "available", value)

    @_builtins.property
    @pulumi.getter
    def limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Total number of seats provided by this subscription for this sku
        """
        return pulumi.get(self, "limit")

    @limit.setter
    def limit(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "limit", value)


if not MYPY:
    class LicensingSubscriptionSubscriptionsClaimKeyValidateParametersArgsDict(TypedDict):
        claim_key: NotRequired[pulumi.Input[_builtins.str]]
        """
        The subscription's claim key
        """
elif False:
    LicensingSubscriptionSubscriptionsClaimKeyValidateParametersArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LicensingSubscriptionSubscriptionsClaimKeyValidateParametersArgs:
    def __init__(__self__, *,
                 claim_key: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] claim_key: The subscription's claim key
        """
        if claim_key is not None:
            pulumi.set(__self__, "claim_key", claim_key)

    @_builtins.property
    @pulumi.getter(name="claimKey")
    def claim_key(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The subscription's claim key
        """
        return pulumi.get(self, "claim_key")

    @claim_key.setter
    def claim_key(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "claim_key", value)


if not MYPY:
    class LicensingSubscriptionSubscriptionsClaimParametersArgsDict(TypedDict):
        claim_key: NotRequired[pulumi.Input[_builtins.str]]
        """
        The subscription's claim key
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Extra details or notes about the subscription
        """
        name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Friendly name to identify the subscription
        """
        organization_id: NotRequired[pulumi.Input[_builtins.str]]
        """
        The id of the organization claiming the subscription
        """
elif False:
    LicensingSubscriptionSubscriptionsClaimParametersArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class LicensingSubscriptionSubscriptionsClaimParametersArgs:
    def __init__(__self__, *,
                 claim_key: Optional[pulumi.Input[_builtins.str]] = None,
                 description: Optional[pulumi.Input[_builtins.str]] = None,
                 name: Optional[pulumi.Input[_builtins.str]] = None,
                 organization_id: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] claim_key: The subscription's claim key
        :param pulumi.Input[_builtins.str] description: Extra details or notes about the subscription
        :param pulumi.Input[_builtins.str] name: Friendly name to identify the subscription
        :param pulumi.Input[_builtins.str] organization_id: The id of the organization claiming the subscription
        """
        if claim_key is not None:
            pulumi.set(__self__, "claim_key", claim_key)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if organization_id is not None:
            pulumi.set(__self__, "organization_id", organization_id)

    @_builtins.property
    @pulumi.getter(name="claimKey")
    def claim_key(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The subscription's claim key
        """
        return pulumi.get(self, "claim_key")

    @claim_key.setter
    def claim_key(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "claim_key", value)

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Extra details or notes about the subscription
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "description", value)

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Friendly name to identify the subscription
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "name", value)

    @_builtins.property
    @pulumi.getter(name="organizationId")
    def organization_id(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The id of the organization claiming the subscription
        """
        return pulumi.get(self, "organization_id")

    @organization_id.setter
    def organization_id(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "organization_id", value)


