k2

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 K2Service struct {
	Options []option.RequestOption
	Streams *StreamService
}

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 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 SortDirection = shared.SortDirection

type StreamDeleteParams struct {
	// Specifies the public ID of the account.
	AccountID param.Field[string] `path:"account_id" api:"required"`
}

type StreamDeleteResponse = interface{}

type StreamDeleteResponseEnvelope struct {
	Errors   []StreamDeleteResponseEnvelopeErrors   `json:"errors" api:"required"`
	Messages []StreamDeleteResponseEnvelopeMessages `json:"messages" api:"required"`
	Result   StreamDeleteResponse                   `json:"result" api:"required"`
	// Indicates whether the API call was successful.
	Success bool                             `json:"success" api:"required"`
	JSON    streamDeleteResponseEnvelopeJSON `json:"-"`
}

type StreamDeleteResponseEnvelopeErrors struct {
	Message string                                 `json:"message" api:"required"`
	Code    int64                                  `json:"code"`
	JSON    streamDeleteResponseEnvelopeErrorsJSON `json:"-"`
}

type StreamDeleteResponseEnvelopeMessages struct {
	Message string                                   `json:"message" api:"required"`
	Code    int64                                    `json:"code"`
	JSON    streamDeleteResponseEnvelopeMessagesJSON `json:"-"`
}

type StreamGetParams struct {
	// Specifies the public ID of the account.
	AccountID param.Field[string] `path:"account_id" api:"required"`
}

type StreamGetResponse struct {
	// Specifies the public ID of the K2 stream.
	ID        string    `json:"id" api:"required"`
	CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
	// Indicates the base HTTP endpoint for producing and consuming records.
	Endpoint string `json:"endpoint" api:"required" format:"uri"`
	// Configures the HTTP endpoint. Disabling HTTP keeps `authentication` and `cors`,
	// so enabling it again restores them.
	HTTP       StreamGetResponseHTTP `json:"http" api:"required"`
	ModifiedAt time.Time             `json:"modified_at" api:"required" format:"date-time"`
	// Indicates the name of the K2 stream.
	Name string `json:"name" api:"required"`
	// Shows the configured record retention period from 1 hour (3600 seconds) to 30
	// days (2592000 seconds), inclusive.
	RetentionSeconds int64                          `json:"retention_seconds" api:"required"`
	WorkerBinding    StreamGetResponseWorkerBinding `json:"worker_binding" api:"required"`
	JSON             streamGetResponseJSON          `json:"-"`
}

type StreamGetResponseEnvelope struct {
	Errors   []StreamGetResponseEnvelopeErrors   `json:"errors" api:"required"`
	Messages []StreamGetResponseEnvelopeMessages `json:"messages" api:"required"`
	Result   StreamGetResponse                   `json:"result" api:"required"`
	// Indicates whether the API call was successful.
	Success bool                          `json:"success" api:"required"`
	JSON    streamGetResponseEnvelopeJSON `json:"-"`
}

type StreamGetResponseEnvelopeErrors struct {
	Message string                              `json:"message" api:"required"`
	Code    int64                               `json:"code"`
	JSON    streamGetResponseEnvelopeErrorsJSON `json:"-"`
}

type StreamGetResponseEnvelopeMessages struct {
	Message string                                `json:"message" api:"required"`
	Code    int64                                 `json:"code"`
	JSON    streamGetResponseEnvelopeMessagesJSON `json:"-"`
}

type StreamGetResponseHTTP struct {
	// Indicates whether the HTTP endpoint accepts records.
	Enabled bool `json:"enabled" api:"required"`
	// Indicates whether the HTTP endpoint requires an API token with K2 produce
	// permission. When false, the endpoint accepts unauthenticated records. Defaults
	// to true when HTTP is enabled without a stored value.
	Authentication bool                      `json:"authentication"`
	CORS           StreamGetResponseHTTPCORS `json:"cors"`
	JSON           streamGetResponseHTTPJSON `json:"-"`
}

type StreamGetResponseHTTPCORS struct {
	// Allows browser requests from these HTTP or HTTPS origins. Use a wildcard only as
	// the sole origin. An empty list blocks cross-origin browser requests. Defaults to
	// `['*']` when HTTP is enabled without stored origins.
	Origins []string                      `json:"origins"`
	JSON    streamGetResponseHttpcorsJSON `json:"-"`
}

type StreamGetResponseWorkerBinding struct {
	// Indicates whether Workers bindings can produce records to the stream.
	Enabled StreamGetResponseWorkerBindingEnabled `json:"enabled" api:"required"`
	JSON    streamGetResponseWorkerBindingJSON    `json:"-"`
	// contains filtered or unexported fields
}

type StreamGetResponseWorkerBindingEnabled struct {
	// Indicates whether Workers bindings can produce records to the stream.
	Enabled StreamGetResponseWorkerBindingEnabledEnabled `json:"enabled" api:"required"`
	JSON    streamGetResponseWorkerBindingEnabledJSON    `json:"-"`
}

type StreamGetResponseWorkerBindingEnabledEnabled bool

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

type StreamListParams struct {
	// Specifies the public ID of the account.
	AccountID param.Field[string] `path:"account_id" api:"required"`
	// Filters K2 streams by name using a case-insensitive substring.
	Name    param.Field[string] `query:"name"`
	Page    param.Field[int64]  `query:"page"`
	PerPage param.Field[int64]  `query:"per_page"`
}

type StreamListResponse struct {
	// Specifies the public ID of the K2 stream.
	ID        string    `json:"id" api:"required"`
	CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
	// Indicates the base HTTP endpoint for producing and consuming records.
	Endpoint string `json:"endpoint" api:"required" format:"uri"`
	// Configures the HTTP endpoint. Disabling HTTP keeps `authentication` and `cors`,
	// so enabling it again restores them.
	HTTP       StreamListResponseHTTP `json:"http" api:"required"`
	ModifiedAt time.Time              `json:"modified_at" api:"required" format:"date-time"`
	// Indicates the name of the K2 stream.
	Name string `json:"name" api:"required"`
	// Shows the configured record retention period from 1 hour (3600 seconds) to 30
	// days (2592000 seconds), inclusive.
	RetentionSeconds int64                           `json:"retention_seconds" api:"required"`
	WorkerBinding    StreamListResponseWorkerBinding `json:"worker_binding" api:"required"`
	JSON             streamListResponseJSON          `json:"-"`
}

type StreamListResponseHTTP struct {
	// Indicates whether the HTTP endpoint accepts records.
	Enabled bool `json:"enabled" api:"required"`
	// Indicates whether the HTTP endpoint requires an API token with K2 produce
	// permission. When false, the endpoint accepts unauthenticated records. Defaults
	// to true when HTTP is enabled without a stored value.
	Authentication bool                       `json:"authentication"`
	CORS           StreamListResponseHTTPCORS `json:"cors"`
	JSON           streamListResponseHTTPJSON `json:"-"`
}

type StreamListResponseHTTPCORS struct {
	// Allows browser requests from these HTTP or HTTPS origins. Use a wildcard only as
	// the sole origin. An empty list blocks cross-origin browser requests. Defaults to
	// `['*']` when HTTP is enabled without stored origins.
	Origins []string                       `json:"origins"`
	JSON    streamListResponseHttpcorsJSON `json:"-"`
}

type StreamListResponseWorkerBinding struct {
	// Indicates whether Workers bindings can produce records to the stream.
	Enabled StreamListResponseWorkerBindingEnabled `json:"enabled" api:"required"`
	JSON    streamListResponseWorkerBindingJSON    `json:"-"`
	// contains filtered or unexported fields
}

type StreamListResponseWorkerBindingEnabled struct {
	// Indicates whether Workers bindings can produce records to the stream.
	Enabled StreamListResponseWorkerBindingEnabledEnabled `json:"enabled" api:"required"`
	JSON    streamListResponseWorkerBindingEnabledJSON    `json:"-"`
}

type StreamListResponseWorkerBindingEnabledEnabled bool

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

type StreamNewParams struct {
	// Specifies the public ID of the account.
	AccountID param.Field[string] `path:"account_id" api:"required"`
	// Specifies the name of the K2 stream.
	Name param.Field[string] `json:"name" api:"required"`
	// Configures the HTTP endpoint. Disabling HTTP keeps `authentication` and `cors`,
	// so enabling it again restores them.
	HTTP param.Field[StreamNewParamsHTTP] `json:"http"`
	// Sets the record retention period from 1 hour (3600 seconds) to 30 days (2592000
	// seconds), inclusive.
	RetentionSeconds param.Field[int64]                             `json:"retention_seconds"`
	WorkerBinding    param.Field[StreamNewParamsWorkerBindingUnion] `json:"worker_binding"`
}

type StreamNewParamsHTTP struct {
	// Indicates whether the HTTP endpoint accepts records.
	Enabled param.Field[bool] `json:"enabled" api:"required"`
	// Indicates whether the HTTP endpoint requires an API token with K2 produce
	// permission. When false, the endpoint accepts unauthenticated records. Defaults
	// to true when HTTP is enabled without a stored value.
	Authentication param.Field[bool]                    `json:"authentication"`
	CORS           param.Field[StreamNewParamsHTTPCORS] `json:"cors"`
}

type StreamNewParamsHTTPCORS struct {
	// Allows browser requests from these HTTP or HTTPS origins. Use a wildcard only as
	// the sole origin. An empty list blocks cross-origin browser requests. Defaults to
	// `['*']` when HTTP is enabled without stored origins.
	Origins param.Field[[]string] `json:"origins"`
}

type StreamNewParamsWorkerBinding struct {
	// Indicates whether Workers bindings can produce records to the stream.
	Enabled param.Field[StreamNewParamsWorkerBindingEnabled] `json:"enabled" api:"required"`
}

type StreamNewParamsWorkerBindingEnabled struct {
	// Indicates whether Workers bindings can produce records to the stream.
	Enabled param.Field[StreamNewParamsWorkerBindingEnabledEnabled] `json:"enabled" api:"required"`
}

type StreamNewParamsWorkerBindingEnabledEnabled bool

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

type StreamNewResponse struct {
	// Specifies the public ID of the K2 stream.
	ID        string    `json:"id" api:"required"`
	CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
	// Indicates the base HTTP endpoint for producing and consuming records.
	Endpoint string `json:"endpoint" api:"required" format:"uri"`
	// Configures the HTTP endpoint. Disabling HTTP keeps `authentication` and `cors`,
	// so enabling it again restores them.
	HTTP       StreamNewResponseHTTP `json:"http" api:"required"`
	ModifiedAt time.Time             `json:"modified_at" api:"required" format:"date-time"`
	// Indicates the name of the K2 stream.
	Name string `json:"name" api:"required"`
	// Shows the configured record retention period from 1 hour (3600 seconds) to 30
	// days (2592000 seconds), inclusive.
	RetentionSeconds int64                          `json:"retention_seconds" api:"required"`
	WorkerBinding    StreamNewResponseWorkerBinding `json:"worker_binding" api:"required"`
	JSON             streamNewResponseJSON          `json:"-"`
}

type StreamNewResponseEnvelope struct {
	Errors   []StreamNewResponseEnvelopeErrors   `json:"errors" api:"required"`
	Messages []StreamNewResponseEnvelopeMessages `json:"messages" api:"required"`
	Result   StreamNewResponse                   `json:"result" api:"required"`
	// Indicates whether the API call was successful.
	Success bool                          `json:"success" api:"required"`
	JSON    streamNewResponseEnvelopeJSON `json:"-"`
}

type StreamNewResponseEnvelopeErrors struct {
	Message string                              `json:"message" api:"required"`
	Code    int64                               `json:"code"`
	JSON    streamNewResponseEnvelopeErrorsJSON `json:"-"`
}

type StreamNewResponseEnvelopeMessages struct {
	Message string                                `json:"message" api:"required"`
	Code    int64                                 `json:"code"`
	JSON    streamNewResponseEnvelopeMessagesJSON `json:"-"`
}

type StreamNewResponseHTTP struct {
	// Indicates whether the HTTP endpoint accepts records.
	Enabled bool `json:"enabled" api:"required"`
	// Indicates whether the HTTP endpoint requires an API token with K2 produce
	// permission. When false, the endpoint accepts unauthenticated records. Defaults
	// to true when HTTP is enabled without a stored value.
	Authentication bool                      `json:"authentication"`
	CORS           StreamNewResponseHTTPCORS `json:"cors"`
	JSON           streamNewResponseHTTPJSON `json:"-"`
}

type StreamNewResponseHTTPCORS struct {
	// Allows browser requests from these HTTP or HTTPS origins. Use a wildcard only as
	// the sole origin. An empty list blocks cross-origin browser requests. Defaults to
	// `['*']` when HTTP is enabled without stored origins.
	Origins []string                      `json:"origins"`
	JSON    streamNewResponseHttpcorsJSON `json:"-"`
}

type StreamNewResponseWorkerBinding struct {
	// Indicates whether Workers bindings can produce records to the stream.
	Enabled StreamNewResponseWorkerBindingEnabled `json:"enabled" api:"required"`
	JSON    streamNewResponseWorkerBindingJSON    `json:"-"`
	// contains filtered or unexported fields
}

type StreamNewResponseWorkerBindingEnabled struct {
	// Indicates whether Workers bindings can produce records to the stream.
	Enabled StreamNewResponseWorkerBindingEnabledEnabled `json:"enabled" api:"required"`
	JSON    streamNewResponseWorkerBindingEnabledJSON    `json:"-"`
}

type StreamNewResponseWorkerBindingEnabledEnabled bool

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

type StreamService struct {
	Options       []option.RequestOption
	Subscriptions *StreamSubscriptionService
}

type StreamSubscriptionListParams struct {
	// Specifies the public ID of the account.
	AccountID param.Field[string] `path:"account_id" api:"required"`
}

type StreamSubscriptionListResponse struct {
	ID         string                                `json:"id" api:"required"`
	CreatedAt  time.Time                             `json:"created_at" api:"required" format:"date-time"`
	Lag        StreamSubscriptionListResponseLag     `json:"lag" api:"required"`
	ModifiedAt time.Time                             `json:"modified_at" api:"required" format:"date-time"`
	Name       string                                `json:"name" api:"required"`
	StartAt    StreamSubscriptionListResponseStartAt `json:"start_at" api:"required"`
	JSON       streamSubscriptionListResponseJSON    `json:"-"`
}

type StreamSubscriptionListResponseLag struct {
	// Decimal-string distance from the subscription's committed position to the
	// observed exclusive stream tail, in records. Includes in-flight records and may
	// include expired records or records acknowledged beyond an earlier gap. Null
	// unless status is available.
	Records string `json:"records" api:"required,nullable"`
	// Unsupported means the subscription or stream topology cannot be measured;
	// unavailable means a required observation failed or was inconsistent.
	Status StreamSubscriptionListResponseLagStatus `json:"status" api:"required"`
	JSON   streamSubscriptionListResponseLagJSON   `json:"-"`
}

type StreamSubscriptionListResponseLagStatus string

type StreamSubscriptionListResponseStartAt struct {
	Type StreamSubscriptionListResponseStartAtType `json:"type" api:"required"`
	JSON streamSubscriptionListResponseStartAtJSON `json:"-"`
}

type StreamSubscriptionListResponseStartAtType string

type StreamSubscriptionService struct {
	Options []option.RequestOption
}

type StreamUpdateParams struct {
	// Specifies the public ID of the account.
	AccountID param.Field[string] `path:"account_id" api:"required"`
	// Configures the HTTP endpoint. Disabling HTTP keeps `authentication` and `cors`,
	// so enabling it again restores them.
	HTTP param.Field[StreamUpdateParamsHTTP] `json:"http"`
	// Sets the record retention period from 1 hour (3600 seconds) to 30 days (2592000
	// seconds), inclusive.
	RetentionSeconds param.Field[int64]                                `json:"retention_seconds"`
	WorkerBinding    param.Field[StreamUpdateParamsWorkerBindingUnion] `json:"worker_binding"`
}

type StreamUpdateParamsHTTP struct {
	// Indicates whether the HTTP endpoint accepts records.
	Enabled param.Field[bool] `json:"enabled" api:"required"`
	// Indicates whether the HTTP endpoint requires an API token with K2 produce
	// permission. When false, the endpoint accepts unauthenticated records. Defaults
	// to true when HTTP is enabled without a stored value.
	Authentication param.Field[bool]                       `json:"authentication"`
	CORS           param.Field[StreamUpdateParamsHTTPCORS] `json:"cors"`
}

type StreamUpdateParamsHTTPCORS struct {
	// Allows browser requests from these HTTP or HTTPS origins. Use a wildcard only as
	// the sole origin. An empty list blocks cross-origin browser requests. Defaults to
	// `['*']` when HTTP is enabled without stored origins.
	Origins param.Field[[]string] `json:"origins"`
}

type StreamUpdateParamsWorkerBinding struct {
	// Indicates whether Workers bindings can produce records to the stream.
	Enabled param.Field[StreamUpdateParamsWorkerBindingEnabled] `json:"enabled" api:"required"`
}

type StreamUpdateParamsWorkerBindingEnabled struct {
	// Indicates whether Workers bindings can produce records to the stream.
	Enabled param.Field[StreamUpdateParamsWorkerBindingEnabledEnabled] `json:"enabled" api:"required"`
}

type StreamUpdateParamsWorkerBindingEnabledEnabled bool

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

type StreamUpdateResponse struct {
	// Specifies the public ID of the K2 stream.
	ID        string    `json:"id" api:"required"`
	CreatedAt time.Time `json:"created_at" api:"required" format:"date-time"`
	// Indicates the base HTTP endpoint for producing and consuming records.
	Endpoint string `json:"endpoint" api:"required" format:"uri"`
	// Configures the HTTP endpoint. Disabling HTTP keeps `authentication` and `cors`,
	// so enabling it again restores them.
	HTTP       StreamUpdateResponseHTTP `json:"http" api:"required"`
	ModifiedAt time.Time                `json:"modified_at" api:"required" format:"date-time"`
	// Indicates the name of the K2 stream.
	Name string `json:"name" api:"required"`
	// Shows the configured record retention period from 1 hour (3600 seconds) to 30
	// days (2592000 seconds), inclusive.
	RetentionSeconds int64                             `json:"retention_seconds" api:"required"`
	WorkerBinding    StreamUpdateResponseWorkerBinding `json:"worker_binding" api:"required"`
	JSON             streamUpdateResponseJSON          `json:"-"`
}

type StreamUpdateResponseEnvelope struct {
	Errors   []StreamUpdateResponseEnvelopeErrors   `json:"errors" api:"required"`
	Messages []StreamUpdateResponseEnvelopeMessages `json:"messages" api:"required"`
	Result   StreamUpdateResponse                   `json:"result" api:"required"`
	// Indicates whether the API call was successful.
	Success bool                             `json:"success" api:"required"`
	JSON    streamUpdateResponseEnvelopeJSON `json:"-"`
}

type StreamUpdateResponseEnvelopeErrors struct {
	Message string                                 `json:"message" api:"required"`
	Code    int64                                  `json:"code"`
	JSON    streamUpdateResponseEnvelopeErrorsJSON `json:"-"`
}

type StreamUpdateResponseEnvelopeMessages struct {
	Message string                                   `json:"message" api:"required"`
	Code    int64                                    `json:"code"`
	JSON    streamUpdateResponseEnvelopeMessagesJSON `json:"-"`
}

type StreamUpdateResponseHTTP struct {
	// Indicates whether the HTTP endpoint accepts records.
	Enabled bool `json:"enabled" api:"required"`
	// Indicates whether the HTTP endpoint requires an API token with K2 produce
	// permission. When false, the endpoint accepts unauthenticated records. Defaults
	// to true when HTTP is enabled without a stored value.
	Authentication bool                         `json:"authentication"`
	CORS           StreamUpdateResponseHTTPCORS `json:"cors"`
	JSON           streamUpdateResponseHTTPJSON `json:"-"`
}

type StreamUpdateResponseHTTPCORS struct {
	// Allows browser requests from these HTTP or HTTPS origins. Use a wildcard only as
	// the sole origin. An empty list blocks cross-origin browser requests. Defaults to
	// `['*']` when HTTP is enabled without stored origins.
	Origins []string                         `json:"origins"`
	JSON    streamUpdateResponseHttpcorsJSON `json:"-"`
}

type StreamUpdateResponseWorkerBinding struct {
	// Indicates whether Workers bindings can produce records to the stream.
	Enabled StreamUpdateResponseWorkerBindingEnabled `json:"enabled" api:"required"`
	JSON    streamUpdateResponseWorkerBindingJSON    `json:"-"`
	// contains filtered or unexported fields
}

type StreamUpdateResponseWorkerBindingEnabled struct {
	// Indicates whether Workers bindings can produce records to the stream.
	Enabled StreamUpdateResponseWorkerBindingEnabledEnabled `json:"enabled" api:"required"`
	JSON    streamUpdateResponseWorkerBindingEnabledJSON    `json:"-"`
}

type StreamUpdateResponseWorkerBindingEnabledEnabled bool

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

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