monetization

type ASN = shared.ASN

type ASNParam = shared.ASNParam

type AuditLog = shared.AuditLog

type AuditLogAction = shared.AuditLogAction

type AuditLogActor = shared.AuditLogActor

type AuditLogActorType = shared.AuditLogActorType

type AuditLogOwner = shared.AuditLogOwner

type AuditLogResource = shared.AuditLogResource

type CertificateCA = shared.CertificateCA

type CertificateRequestType = shared.CertificateRequestType

type CloudflareTunnel = shared.CloudflareTunnel

type CloudflareTunnelConfigSrc = shared.CloudflareTunnelConfigSrc

type CloudflareTunnelConnection = shared.CloudflareTunnelConnection

type CloudflareTunnelStatus = shared.CloudflareTunnelStatus

type CloudflareTunnelTunType = shared.CloudflareTunnelTunType

type Error = apierror.Error

type ErrorData = shared.ErrorData

type ErrorDataSource = shared.ErrorDataSource

type Member = shared.Member

type MemberPoliciesAccess = shared.MemberPoliciesAccess

type MemberPoliciesPermissionGroup = shared.MemberPoliciesPermissionGroup

type MemberPoliciesPermissionGroupsMeta = shared.MemberPoliciesPermissionGroupsMeta

type MemberPoliciesResourceGroup = shared.MemberPoliciesResourceGroup

type MemberPoliciesResourceGroupsMeta = shared.MemberPoliciesResourceGroupsMeta

type MemberPoliciesResourceGroupsScope = shared.MemberPoliciesResourceGroupsScope

type MemberPoliciesResourceGroupsScopeObject = shared.MemberPoliciesResourceGroupsScopeObject

type MemberPolicy = shared.MemberPolicy

type MemberStatus = shared.MemberStatus

type MemberUser = shared.MemberUser

type MonetizationRule struct {
	// Optional on input. Include the ID of an existing payment rule to update it in
	// place, preserving its stable identity across the full-ruleset replacement; omit
	// it to create a new rule. An ID that does not match an existing payment rule in
	// the zone is rejected. Rules omitted from the request are deleted.
	ID string `json:"id"`
	// 0x-prefixed 20-byte hexadecimal Ethereum address. Mixed-case addresses must
	// carry a valid EIP-55 checksum; all-lowercase or all-uppercase addresses are also
	// accepted. The address must pass wallet screening whenever its rule is deployed
	// or patched.
	Address     string `json:"address"`
	Description string `json:"description"`
	Enabled     bool   `json:"enabled"`
	// Wirefilter expression identifying the requests that require payment. Forwarded
	// verbatim to the Rulesets API, which validates its syntax.
	Expression string `json:"expression"`
	// Price in the smallest indivisible unit of the configured payment token, encoded
	// as a decimal string. Must be a canonical decimal integer in [1000, 100000000]:
	// no leading zeros, and a bare JSON number is rejected. The price is required for
	// the fixed-price schemes ("exact" and "upto") and must be at least 1000, the
	// smallest amount the payment facilitator can settle ($0.001 for a 6-decimal token
	// such as USDC), and at most 100000000 ($100 for a 6-decimal token). When the
	// scheme is "origin_controlled" the origin server sets pricing dynamically and the
	// rule carries no price: the field must be omitted — any provided value, including
	// "0", is rejected because it would not be enforced. Responses always encode this
	// as a string and omit it for "origin_controlled" rules; the pattern matches
	// exactly the set of values the server accepts.
	Price string `json:"price"`
	// X402 payment scheme. "exact" requires the specified payment amount; "upto"
	// permits a payment up to the specified amount. Both fixed-price schemes require
	// the price field.
	Scheme MonetizationRuleScheme `json:"scheme"`
	JSON   monetizationRuleJSON   `json:"-"`
	// contains filtered or unexported fields
}

type MonetizationRuleCollection struct {
	// The zone's payment rules, in the order they are evaluated. Empty when the zone
	// has no payment rules.
	Rules []MonetizationRule             `json:"rules" api:"required"`
	JSON  monetizationRuleCollectionJSON `json:"-"`
}

type MonetizationRuleInputFixedPrice struct {
	// 0x-prefixed 20-byte hexadecimal Ethereum address. Mixed-case addresses must
	// carry a valid EIP-55 checksum; all-lowercase or all-uppercase addresses are also
	// accepted. The address must pass wallet screening whenever its rule is deployed
	// or patched.
	Address string `json:"address" api:"required"`
	// Wirefilter expression identifying the requests that require payment. Forwarded
	// verbatim to the Rulesets API, which validates its syntax.
	Expression string `json:"expression" api:"required"`
	// Price in the smallest indivisible unit of the configured payment token, encoded
	// as a decimal string. Must be a canonical decimal integer in [1000, 100000000]:
	// no leading zeros, and a bare JSON number is rejected. The price is required for
	// the fixed-price schemes ("exact" and "upto") and must be at least 1000, the
	// smallest amount the payment facilitator can settle ($0.001 for a 6-decimal token
	// such as USDC), and at most 100000000 ($100 for a 6-decimal token). When the
	// scheme is "origin_controlled" the origin server sets pricing dynamically and the
	// rule carries no price: the field must be omitted — any provided value, including
	// "0", is rejected because it would not be enforced. Responses always encode this
	// as a string and omit it for "origin_controlled" rules; the pattern matches
	// exactly the set of values the server accepts.
	Price string `json:"price" api:"required"`
	// X402 payment scheme. "exact" requires the specified payment amount; "upto"
	// permits a payment up to the specified amount. Both fixed-price schemes require
	// the price field.
	Scheme MonetizationRuleInputFixedPriceScheme `json:"scheme" api:"required"`
	// Optional on input. Include the ID of an existing payment rule to update it in
	// place, preserving its stable identity across the full-ruleset replacement; omit
	// it to create a new rule. An ID that does not match an existing payment rule in
	// the zone is rejected. Rules omitted from the request are deleted.
	ID          string                              `json:"id"`
	Description string                              `json:"description"`
	Enabled     bool                                `json:"enabled"`
	JSON        monetizationRuleInputFixedPriceJSON `json:"-"`
}

type MonetizationRuleInputFixedPriceParam struct {
	// 0x-prefixed 20-byte hexadecimal Ethereum address. Mixed-case addresses must
	// carry a valid EIP-55 checksum; all-lowercase or all-uppercase addresses are also
	// accepted. The address must pass wallet screening whenever its rule is deployed
	// or patched.
	Address param.Field[string] `json:"address" api:"required"`
	// Wirefilter expression identifying the requests that require payment. Forwarded
	// verbatim to the Rulesets API, which validates its syntax.
	Expression param.Field[string] `json:"expression" api:"required"`
	// Price in the smallest indivisible unit of the configured payment token, encoded
	// as a decimal string. Must be a canonical decimal integer in [1000, 100000000]:
	// no leading zeros, and a bare JSON number is rejected. The price is required for
	// the fixed-price schemes ("exact" and "upto") and must be at least 1000, the
	// smallest amount the payment facilitator can settle ($0.001 for a 6-decimal token
	// such as USDC), and at most 100000000 ($100 for a 6-decimal token). When the
	// scheme is "origin_controlled" the origin server sets pricing dynamically and the
	// rule carries no price: the field must be omitted — any provided value, including
	// "0", is rejected because it would not be enforced. Responses always encode this
	// as a string and omit it for "origin_controlled" rules; the pattern matches
	// exactly the set of values the server accepts.
	Price param.Field[string] `json:"price" api:"required"`
	// X402 payment scheme. "exact" requires the specified payment amount; "upto"
	// permits a payment up to the specified amount. Both fixed-price schemes require
	// the price field.
	Scheme param.Field[MonetizationRuleInputFixedPriceScheme] `json:"scheme" api:"required"`
	// Optional on input. Include the ID of an existing payment rule to update it in
	// place, preserving its stable identity across the full-ruleset replacement; omit
	// it to create a new rule. An ID that does not match an existing payment rule in
	// the zone is rejected. Rules omitted from the request are deleted.
	ID          param.Field[string] `json:"id"`
	Description param.Field[string] `json:"description"`
	Enabled     param.Field[bool]   `json:"enabled"`
}

type MonetizationRuleInputFixedPriceScheme string

type MonetizationRuleInputOriginControlled struct {
	// 0x-prefixed 20-byte hexadecimal Ethereum address. Mixed-case addresses must
	// carry a valid EIP-55 checksum; all-lowercase or all-uppercase addresses are also
	// accepted. The address must pass wallet screening whenever its rule is deployed
	// or patched.
	Address string `json:"address" api:"required"`
	// Wirefilter expression identifying the requests that require payment. Forwarded
	// verbatim to the Rulesets API, which validates its syntax.
	Expression string `json:"expression" api:"required"`
	// X402 payment scheme. "origin_controlled" lets the origin server set pricing
	// dynamically; the rule carries no price and the price field must be omitted.
	Scheme MonetizationRuleInputOriginControlledScheme `json:"scheme" api:"required"`
	// Optional on input. Include the ID of an existing payment rule to update it in
	// place, preserving its stable identity across the full-ruleset replacement; omit
	// it to create a new rule. An ID that does not match an existing payment rule in
	// the zone is rejected. Rules omitted from the request are deleted.
	ID          string                                    `json:"id"`
	Description string                                    `json:"description"`
	Enabled     bool                                      `json:"enabled"`
	JSON        monetizationRuleInputOriginControlledJSON `json:"-"`
}

type MonetizationRuleInputOriginControlledParam struct {
	// 0x-prefixed 20-byte hexadecimal Ethereum address. Mixed-case addresses must
	// carry a valid EIP-55 checksum; all-lowercase or all-uppercase addresses are also
	// accepted. The address must pass wallet screening whenever its rule is deployed
	// or patched.
	Address param.Field[string] `json:"address" api:"required"`
	// Wirefilter expression identifying the requests that require payment. Forwarded
	// verbatim to the Rulesets API, which validates its syntax.
	Expression param.Field[string] `json:"expression" api:"required"`
	// X402 payment scheme. "origin_controlled" lets the origin server set pricing
	// dynamically; the rule carries no price and the price field must be omitted.
	Scheme param.Field[MonetizationRuleInputOriginControlledScheme] `json:"scheme" api:"required"`
	// Optional on input. Include the ID of an existing payment rule to update it in
	// place, preserving its stable identity across the full-ruleset replacement; omit
	// it to create a new rule. An ID that does not match an existing payment rule in
	// the zone is rejected. Rules omitted from the request are deleted.
	ID          param.Field[string] `json:"id"`
	Description param.Field[string] `json:"description"`
	Enabled     param.Field[bool]   `json:"enabled"`
}

type MonetizationRuleInputOriginControlledScheme string

type MonetizationRuleInputParam struct {
	// 0x-prefixed 20-byte hexadecimal Ethereum address. Mixed-case addresses must
	// carry a valid EIP-55 checksum; all-lowercase or all-uppercase addresses are also
	// accepted. The address must pass wallet screening whenever its rule is deployed
	// or patched.
	Address param.Field[string] `json:"address" api:"required"`
	// Wirefilter expression identifying the requests that require payment. Forwarded
	// verbatim to the Rulesets API, which validates its syntax.
	Expression param.Field[string] `json:"expression" api:"required"`
	// X402 payment scheme. "exact" requires the specified payment amount; "upto"
	// permits a payment up to the specified amount. Both fixed-price schemes require
	// the price field.
	Scheme param.Field[MonetizationRuleInputScheme] `json:"scheme" api:"required"`
	// Optional on input. Include the ID of an existing payment rule to update it in
	// place, preserving its stable identity across the full-ruleset replacement; omit
	// it to create a new rule. An ID that does not match an existing payment rule in
	// the zone is rejected. Rules omitted from the request are deleted.
	ID          param.Field[string] `json:"id"`
	Description param.Field[string] `json:"description"`
	Enabled     param.Field[bool]   `json:"enabled"`
	// Price in the smallest indivisible unit of the configured payment token, encoded
	// as a decimal string. Must be a canonical decimal integer in [1000, 100000000]:
	// no leading zeros, and a bare JSON number is rejected. The price is required for
	// the fixed-price schemes ("exact" and "upto") and must be at least 1000, the
	// smallest amount the payment facilitator can settle ($0.001 for a 6-decimal token
	// such as USDC), and at most 100000000 ($100 for a 6-decimal token). When the
	// scheme is "origin_controlled" the origin server sets pricing dynamically and the
	// rule carries no price: the field must be omitted — any provided value, including
	// "0", is rejected because it would not be enforced. Responses always encode this
	// as a string and omit it for "origin_controlled" rules; the pattern matches
	// exactly the set of values the server accepts.
	Price param.Field[string] `json:"price"`
}

type MonetizationRuleInputScheme string

type MonetizationRuleInputUnionParam interface {
	// contains filtered or unexported methods
}

type MonetizationRuleMonetizationRulesMonetizationRuleInputFixedPrice struct {
	// The server-assigned unique ID of the payment rule. Stable across full-ruleset
	// replacements.
	ID   string                                                               `json:"id" api:"required"`
	JSON monetizationRuleMonetizationRulesMonetizationRuleInputFixedPriceJSON `json:"-"`
	MonetizationRuleInputFixedPrice
}

type MonetizationRuleMonetizationRulesMonetizationRuleInputOriginControlled struct {
	// The server-assigned unique ID of the payment rule. Stable across full-ruleset
	// replacements.
	ID   string                                                                     `json:"id" api:"required"`
	JSON monetizationRuleMonetizationRulesMonetizationRuleInputOriginControlledJSON `json:"-"`
	MonetizationRuleInputOriginControlled
}

type MonetizationRulePatchParam struct {
	// 0x-prefixed 20-byte hexadecimal Ethereum address. Mixed-case addresses must
	// carry a valid EIP-55 checksum; all-lowercase or all-uppercase addresses are also
	// accepted. The effective address must pass wallet screening whenever the rule is
	// patched.
	Address     param.Field[string] `json:"address"`
	Description param.Field[string] `json:"description"`
	Enabled     param.Field[bool]   `json:"enabled"`
	// Wirefilter expression identifying the requests that require payment. Forwarded
	// verbatim to the Rulesets API, which validates its syntax.
	Expression param.Field[string] `json:"expression"`
	// Price in the smallest indivisible unit of the configured payment token, encoded
	// as a decimal string. Must be a canonical decimal integer in [1000, 100000000]:
	// no leading zeros, and a bare JSON number is rejected. The price is required for
	// the fixed-price schemes ("exact" and "upto") and must be at least 1000, the
	// smallest amount the payment facilitator can settle ($0.001 for a 6-decimal token
	// such as USDC), and at most 100000000 ($100 for a 6-decimal token). When the
	// scheme is "origin_controlled" the origin server sets pricing dynamically and the
	// rule carries no price: the field must be omitted — any provided value, including
	// "0", is rejected because it would not be enforced. Responses always encode this
	// as a string and omit it for "origin_controlled" rules; the pattern matches
	// exactly the set of values the server accepts.
	Price param.Field[string] `json:"price"`
	// X402 payment scheme. "exact" requires the specified payment amount; "upto"
	// permits a payment up to the specified amount; "origin_controlled" lets the
	// origin server set pricing dynamically, in which case the rule carries no price
	// and the price field must be omitted.
	Scheme param.Field[MonetizationRulePatchScheme] `json:"scheme"`
}

type MonetizationRulePatchScheme string

type MonetizationRuleScheme string

type MonetizationRuleUnion interface {
	// contains filtered or unexported methods
}

type MonetizationRulesetInputParam struct {
	// Full desired Payment Required ruleset. An empty array clears all payment rules.
	// The ruleset may contain at most 40 unique wallet addresses; address comparison
	// is case-insensitive. Every address must pass wallet screening before deployment.
	Rules param.Field[[]MonetizationRuleInputUnionParam] `json:"rules" api:"required"`
}

type MonetizationService struct {
	Options []option.RequestOption
	Rules   *RuleService
}

type Permission = shared.Permission

type PermissionGrant = shared.PermissionGrant

type PermissionGrantParam = shared.PermissionGrantParam

type RatePlan = shared.RatePlan

type RatePlanID = shared.RatePlanID

type RatePlanParam = shared.RatePlanParam

type ResponseInfo = shared.ResponseInfo

type ResponseInfoSource = shared.ResponseInfoSource

type Role = shared.Role

type RoleParam = shared.RoleParam

type RolePermissions = shared.RolePermissions

type RolePermissionsParam = shared.RolePermissionsParam

type RuleDeleteParams struct {
	// The unique ID of the zone.
	ZoneID param.Field[string] `path:"zone_id" api:"required"`
}

type RuleDeleteResponseEnvelope struct {
	Errors   []RuleDeleteResponseEnvelopeErrors   `json:"errors" api:"required"`
	Messages []RuleDeleteResponseEnvelopeMessages `json:"messages" api:"required"`
	// The zone's payment rules. Mirrors the shape of the ruleset submitted to the
	// deploy endpoint, so the response can be read back as the desired state.
	Result  MonetizationRuleCollection        `json:"result" api:"required"`
	Success RuleDeleteResponseEnvelopeSuccess `json:"success" api:"required"`
	JSON    ruleDeleteResponseEnvelopeJSON    `json:"-"`
}

type RuleDeleteResponseEnvelopeErrors struct {
	Code    int64                                `json:"code"`
	Message string                               `json:"message"`
	JSON    ruleDeleteResponseEnvelopeErrorsJSON `json:"-"`
}

type RuleDeleteResponseEnvelopeMessages struct {
	Code    int64                                  `json:"code"`
	Message string                                 `json:"message"`
	JSON    ruleDeleteResponseEnvelopeMessagesJSON `json:"-"`
}

type RuleDeleteResponseEnvelopeSuccess bool

type RuleDeleteRuleParams struct {
	// The unique ID of the zone.
	ZoneID param.Field[string] `path:"zone_id" api:"required"`
}

type RuleDeleteRuleResponseEnvelope struct {
	Errors   []RuleDeleteRuleResponseEnvelopeErrors   `json:"errors" api:"required"`
	Messages []RuleDeleteRuleResponseEnvelopeMessages `json:"messages" api:"required"`
	// The zone's payment rules. Mirrors the shape of the ruleset submitted to the
	// deploy endpoint, so the response can be read back as the desired state.
	Result  MonetizationRuleCollection            `json:"result" api:"required"`
	Success RuleDeleteRuleResponseEnvelopeSuccess `json:"success" api:"required"`
	JSON    ruleDeleteRuleResponseEnvelopeJSON    `json:"-"`
}

type RuleDeleteRuleResponseEnvelopeErrors struct {
	Code    int64                                    `json:"code"`
	Message string                                   `json:"message"`
	JSON    ruleDeleteRuleResponseEnvelopeErrorsJSON `json:"-"`
}

type RuleDeleteRuleResponseEnvelopeMessages struct {
	Code    int64                                      `json:"code"`
	Message string                                     `json:"message"`
	JSON    ruleDeleteRuleResponseEnvelopeMessagesJSON `json:"-"`
}

type RuleDeleteRuleResponseEnvelopeSuccess bool

type RuleEditRuleParams struct {
	// The unique ID of the zone.
	ZoneID param.Field[string] `path:"zone_id" api:"required"`
	// Partial update to a single payment rule. Only the fields present are modified;
	// omitted fields keep their existing values.
	MonetizationRulePatch MonetizationRulePatchParam `json:"monetization_rule_patch" api:"required"`
}

type RuleEditRuleResponseEnvelope struct {
	Errors   []RuleEditRuleResponseEnvelopeErrors   `json:"errors" api:"required"`
	Messages []RuleEditRuleResponseEnvelopeMessages `json:"messages" api:"required"`
	// The zone's payment rules. Mirrors the shape of the ruleset submitted to the
	// deploy endpoint, so the response can be read back as the desired state.
	Result  MonetizationRuleCollection          `json:"result" api:"required"`
	Success RuleEditRuleResponseEnvelopeSuccess `json:"success" api:"required"`
	JSON    ruleEditRuleResponseEnvelopeJSON    `json:"-"`
}

type RuleEditRuleResponseEnvelopeErrors struct {
	Code    int64                                  `json:"code"`
	Message string                                 `json:"message"`
	JSON    ruleEditRuleResponseEnvelopeErrorsJSON `json:"-"`
}

type RuleEditRuleResponseEnvelopeMessages struct {
	Code    int64                                    `json:"code"`
	Message string                                   `json:"message"`
	JSON    ruleEditRuleResponseEnvelopeMessagesJSON `json:"-"`
}

type RuleEditRuleResponseEnvelopeSuccess bool

type RuleGetParams struct {
	// The unique ID of the zone.
	ZoneID param.Field[string] `path:"zone_id" api:"required"`
}

type RuleGetResponseEnvelope struct {
	Errors   []RuleGetResponseEnvelopeErrors   `json:"errors" api:"required"`
	Messages []RuleGetResponseEnvelopeMessages `json:"messages" api:"required"`
	// The zone's payment rules. Mirrors the shape of the ruleset submitted to the
	// deploy endpoint, so the response can be read back as the desired state.
	Result  MonetizationRuleCollection     `json:"result" api:"required"`
	Success RuleGetResponseEnvelopeSuccess `json:"success" api:"required"`
	JSON    ruleGetResponseEnvelopeJSON    `json:"-"`
}

type RuleGetResponseEnvelopeErrors struct {
	Code    int64                             `json:"code"`
	Message string                            `json:"message"`
	JSON    ruleGetResponseEnvelopeErrorsJSON `json:"-"`
}

type RuleGetResponseEnvelopeMessages struct {
	Code    int64                               `json:"code"`
	Message string                              `json:"message"`
	JSON    ruleGetResponseEnvelopeMessagesJSON `json:"-"`
}

type RuleGetResponseEnvelopeSuccess bool

type RuleGetRuleParams struct {
	// The unique ID of the zone.
	ZoneID param.Field[string] `path:"zone_id" api:"required"`
}

type RuleGetRuleResponseEnvelope struct {
	Errors   []RuleGetRuleResponseEnvelopeErrors   `json:"errors" api:"required"`
	Messages []RuleGetRuleResponseEnvelopeMessages `json:"messages" api:"required"`
	// Payment rule with a fixed price set at configuration time.
	Result  MonetizationRule                   `json:"result" api:"required"`
	Success RuleGetRuleResponseEnvelopeSuccess `json:"success" api:"required"`
	JSON    ruleGetRuleResponseEnvelopeJSON    `json:"-"`
}

type RuleGetRuleResponseEnvelopeErrors struct {
	Code    int64                                 `json:"code"`
	Message string                                `json:"message"`
	JSON    ruleGetRuleResponseEnvelopeErrorsJSON `json:"-"`
}

type RuleGetRuleResponseEnvelopeMessages struct {
	Code    int64                                   `json:"code"`
	Message string                                  `json:"message"`
	JSON    ruleGetRuleResponseEnvelopeMessagesJSON `json:"-"`
}

type RuleGetRuleResponseEnvelopeSuccess bool

type RuleService struct {
	Options []option.RequestOption
}

type RuleUpdateParams struct {
	// The unique ID of the zone.
	ZoneID                   param.Field[string]           `path:"zone_id" api:"required"`
	MonetizationRulesetInput MonetizationRulesetInputParam `json:"monetization_ruleset_input" api:"required"`
}

type RuleUpdateResponseEnvelope struct {
	Errors   []RuleUpdateResponseEnvelopeErrors   `json:"errors" api:"required"`
	Messages []RuleUpdateResponseEnvelopeMessages `json:"messages" api:"required"`
	// The zone's payment rules. Mirrors the shape of the ruleset submitted to the
	// deploy endpoint, so the response can be read back as the desired state.
	Result  MonetizationRuleCollection        `json:"result" api:"required"`
	Success RuleUpdateResponseEnvelopeSuccess `json:"success" api:"required"`
	JSON    ruleUpdateResponseEnvelopeJSON    `json:"-"`
}

type RuleUpdateResponseEnvelopeErrors struct {
	Code    int64                                `json:"code"`
	Message string                               `json:"message"`
	JSON    ruleUpdateResponseEnvelopeErrorsJSON `json:"-"`
}

type RuleUpdateResponseEnvelopeMessages struct {
	Code    int64                                  `json:"code"`
	Message string                                 `json:"message"`
	JSON    ruleUpdateResponseEnvelopeMessagesJSON `json:"-"`
}

type RuleUpdateResponseEnvelopeSuccess bool

type SortDirection = shared.SortDirection

type Subscription = shared.Subscription

type SubscriptionFrequency = shared.SubscriptionFrequency

type SubscriptionParam = shared.SubscriptionParam

type SubscriptionState = shared.SubscriptionState

type Token = shared.Token

type TokenCondition = shared.TokenCondition

type TokenConditionCIDRList = shared.TokenConditionCIDRList

type TokenConditionCIDRListParam = shared.TokenConditionCIDRListParam

type TokenConditionParam = shared.TokenConditionParam

type TokenConditionRequestIP = shared.TokenConditionRequestIP

type TokenConditionRequestIPParam = shared.TokenConditionRequestIPParam

type TokenParam = shared.TokenParam

type TokenPolicy = shared.TokenPolicy

type TokenPolicyEffect = shared.TokenPolicyEffect

type TokenPolicyParam = shared.TokenPolicyParam

type TokenPolicyPermissionGroup = shared.TokenPolicyPermissionGroup

type TokenPolicyPermissionGroupParam = shared.TokenPolicyPermissionGroupParam

type TokenPolicyPermissionGroupsMeta = shared.TokenPolicyPermissionGroupsMeta

type TokenPolicyPermissionGroupsMetaParam = shared.TokenPolicyPermissionGroupsMetaParam

type TokenPolicyResourcesIAMResourcesTypeObjectNested = shared.TokenPolicyResourcesIAMResourcesTypeObjectNested

type TokenPolicyResourcesIAMResourcesTypeObjectNestedParam = shared.TokenPolicyResourcesIAMResourcesTypeObjectNestedParam

type TokenPolicyResourcesIAMResourcesTypeObjectString = shared.TokenPolicyResourcesIAMResourcesTypeObjectString

type TokenPolicyResourcesIAMResourcesTypeObjectStringParam = shared.TokenPolicyResourcesIAMResourcesTypeObjectStringParam

type TokenPolicyResourcesUnion = shared.TokenPolicyResourcesUnion

type TokenPolicyResourcesUnionParam = shared.TokenPolicyResourcesUnionParam

type TokenStatus = shared.TokenStatus

type TokenValue = shared.TokenValue