licenseapi

type Analytics struct {
	// Endpoint is the endpoint for the analytics server.
	Endpoint string `json:"endpoint,omitempty"`
	// Requests is a slice of requested resources to return analytics for.
	// +optional
	Requests []Request `json:"requests,omitempty"`
}

type Announcement struct {
	// Name contains the resource name of the announcement
	Name string `json:"name,omitempty"`
	// Title contains the title of the announcement in HTML format.
	Title string `json:"title,omitempty"`
	// Body contains the main message of the announcement in HTML format.
	Body string `json:"body,omitempty"`
	// Buttons to show alongside the announcement
	Buttons []*Button `json:"buttons,omitempty"`
}

type BlockRequest struct {
	Request `json:",inline"`

	Overage *ResourceCount `json:"overage,omitempty"`
}

type Button struct {
	// Name is the name of the button (ButtonName). Optional.
	// +optional
	Name string `json:"name,omitempty"`

	// URL is the link at the other end of the button.
	ActionURL string `json:"url"`
	// DisplayText is the text to display on the button. If display text is unset the button will
	// never be shown in the Devsy UI.
	// +optional
	DisplayText string `json:"displayText,omitempty"`
	// Direct indicates if the Devsy front end should directly hit this endpoint. If false, it means
	// that the Devsy front end will be hitting the license server first to generate a one time token
	// for the operation; this also means that there will be a redirect URL in the response to the
	// request for this and that link should be followed by the front end.
	// +optional
	Direct bool `json:"direct,omitempty"`
}

type ButtonName string

type ChatAuthCreateInput struct {
	*InstanceTokenAuth `json:",inline" hash:"-"`

	Provider string `json:"provider,omitempty"`
	Name     string `json:"name,omitempty"`
	Email    string `json:"email,omitempty"`
	Username string `json:"username,omitempty"`
}

type ChatAuthCreateOutput struct {
	Hash string `json:"hash,omitempty"`
}

type DevsyClusterInfo struct {
	UID               string   `json:"uid"`
	Name              string   `json:"name"`
	Namespace         string   `json:"namespace"`
	CreationTimestamp string   `json:"creation_timestamp"`
	IsAvailable       bool     `json:"is_available"`
	NodeMachineIDs    []string `json:"node_machine_ids"`
}

type DomainToken struct {
	URL string `json:"url"`
}

type Feature struct {
	// Name is the name of the feature (FeatureName)
	// This cannot be FeatureName because it needs to be downward compatible
	// e.g. older Devsy version doesn't know a newer feature but it will still be received
	// and still needs to be rendered in the license view
	Name string `json:"name"`

	// +optional
	DisplayName string `json:"displayName,omitempty"`

	// Preview represents whether the feature can be previewed if a user's license does not allow the feature
	// +optional
	Preview bool `json:"preview,omitempty"`

	// AllowBefore is an optional timestamp. If set, licenses issued before this time are allowed
	// to use the feature even if it's not included in the license.
	// +optional
	AllowBefore string `json:"allowBefore,omitempty"`

	// Status shows the status of the feature (see type FeatureStatus)
	// +optional
	Status string `json:"status,omitempty"`

	// Name of the module that this feature belongs to
	// +optional
	Module string `json:"module,omitempty"`
}

type FeatureName string

type FeatureStatus string

type FeatureUsage struct {
	Used   bool   `json:"used"`
	Status string `json:"status"`
}

type GenericRequestInput struct {
	*InstanceTokenAuth `json:",inline,omitempty" hash:"-"`

	// Payload provides the json encoded payload
	// +optional
	Payload string `json:"payload,omitempty"`

	// ReturnURL is the url from which the request is initiated
	// +optional
	ReturnURL string `json:"returnURL,omitempty"`
}

type GenericRequestOutput struct {
	// RedirectURL to redirect the user to.
	// +optional
	RedirectURL string `json:"redirectURL,omitempty"`

	// HTML to display to the user.
	// +optional
	HTML string `json:"html,omitempty"`

	// Buttons to be shown to the user alongside other content (e.g. HTML).
	// +optional
	Buttons []Button `json:"buttons,omitempty"`
}

type InstanceActivateInstanceInput struct {
	ActivationCode string `json:"activationCode"`
}

type InstanceCreateInput struct {
	*InstanceTokenAuth `json:",inline" hash:"-"`

	// Product is the product that is being used. Can be empty, devsy or devsy-pro.
	// This should NOT be a ProductName but a string to allow for downward compatibility
	Product string `json:"product,omitempty" form:"product"`

	// StaticToken is a token for the instance. This is used for testing purposes or for instances that use a static token.
	StaticToken string `json:"staticToken,omitempty" form:"staticToken" hash:"-"`

	// Email is the admin email. Can be empty if no email is specified.
	Email string `json:"email,omitempty" form:"email"`

	DevsyVersion string `json:"version"     form:"version"     validate:"required"`
	KubeVersion  string `json:"kubeVersion" form:"kubeVersion" validate:"required"`

	KubeSystemNamespaceUID string `json:"kubeSystemNamespace" form:"kubeSystemNamespaceUID" validate:"required"`

	// ResourceUsage contains information about the number of resources used
	ResourceUsage map[string]ResourceCount `json:"resources,omitempty" form:"resources"`

	// FeatureUse contains information about what features are used
	FeatureUsage map[string]bool `json:"features,omitempty" form:"features"`

	// DebugInstanceID is the ID of the instance. This is only used for testing purposes.
	// Should never be sent from production instances.
	// Requires authentication via an access key.
	DebugInstanceID *string `json:"debugInstanceID,omitempty" form:"debugInstanceID" hash:"-"`

	// PlatformDatabase reports details about the platform database to the license service
	PlatformDatabase *PlatformDatabase `json:"platformDatabase,omitempty" form:"platformDatabase"`
}

type InstanceCreateOutput struct {
	// License is the license data for the requested Devsy instance.
	License     *License `json:"license,omitempty"`
	CurrentTime int64    `json:"currentTime"`
}

type InstanceSendActivationEmailInput struct {
	Email string `json:"email"`
}

type InstanceTokenAuth struct {
	// Token is the jwt token identifying the Devsy instance.
	Token string `json:"token" query:"token" validate:"required"`
	// Certificate is the signing certificate for the token.
	Certificate string `json:"certificate" form:"certificate" query:"certificate" validate:"required"`
}

type InstanceTokenClaims struct {
	// URLHash is the hash of the url to be signed with this token
	URLHash string `json:"url"`

	// PayloadHash is the hash of the payload to be signed with this token
	PayloadHash string `json:"payload"`
}

type InstanceUsageInput struct {
	// KubeSystemNamespaceUID is the UID of the kube system namespace.
	KubeSystemNamespaceUID string `json:"kubeSystemNamespace"`

	// Type is the type of usage data to be sent to the license service.
	Type string `json:"type"`

	// Data is the data to be sent to the license service.
	Data []byte `json:"data"`
}

type Invoice struct {
	// Date contains the unix timestamp marking the date this invoices was or will be created
	// +optional
	Date int64 `json:"date,omitempty"`

	// Total is the total of the invoice
	// +optional
	Total int64 `json:"total,omitempty"`

	// Currency specifies the currency of Total in 3-character ISO 4217 code
	// Default is: "" (representing USD)
	// +optional
	Currency string `json:"currency,omitempty"`
}

type License struct {
	// InstanceID contains the instance id of the Devsy instance
	InstanceID string `json:"instance,omitempty"`
	// Entity holds a name for an organization, person or entity this product is licensed for. This will be displayed to the user.
	Entity string `json:"entity,omitempty"`

	// Annotations contains additional metadata about the license.
	// +optional
	Annotations map[string]string `json:"annotations,omitempty"`
	// Analytics indicates the analytics endpoints and which requests should be sent to the
	// analytics server.
	// +optional
	Analytics *Analytics `json:"analytics,omitempty"`
	// DomainToken holds the JWT with the URL that the Devsy instance is publicly available on.
	// (via Devsy router)
	// +optional
	DomainToken string `json:"domainToken"`
	// Buttons is a slice of license server endpoints (buttons) that the Devsy instance may need to
	// hit. Each Button contains the display text and link for the front end to work with.
	Buttons []*Button `json:"buttons,omitempty"`
	// Announcements is a map string/string such that we can easily add any additional data without
	// needing to change types. For now, we will use the keys "name" and "content".
	// +optional
	Announcements []*Announcement `json:"announcement,omitempty"`
	// Modules is a list of modules.
	// +optional
	Modules []*Module `json:"modules,omitempty"`
	// BlockRequests specifies which requests the product should block when a limit is exceeded.
	// +optional
	BlockRequests []BlockRequest `json:"block,omitempty"`
	// IsOffline indicates if the license is an offline license or not.
	// +optional
	IsOffline bool `json:"isOffline,omitempty"`

	// +optional
	Routes LicenseAPIRoutes `json:"routes,omitempty"`

	// Plans contains a list of plans
	// +optional
	Plans []Plan `json:"plans,omitempty"`

	// Usage data contains  resource usage information for a platform deployment
	// +optional
	UsageData UsageData `json:"usageData,omitempty"`
}

type LicenseAPIRoute struct {
	URL    string `json:"url,omitempty"`
	Method string `json:"method,omitempty"`

	// Tells the frontend whether to make a direct request or to make it via the backend (via generic license api request)
	// +optional
	Direct bool `json:"direct,omitempty"`
}

type LicenseAPIRoutes struct {
	ChatAuth LicenseAPIRoute `json:"chatAuth,omitempty"`

	FeatureDetails LicenseAPIRoute `json:"featureDetails,omitempty"`
	FeatureSetup   LicenseAPIRoute `json:"featureSetup,omitempty"`
	FeaturePreview LicenseAPIRoute `json:"featurePreview,omitempty"`

	ModuleActivation LicenseAPIRoute `json:"moduleActivation,omitempty"`
	ModulePreview    LicenseAPIRoute `json:"modulePreview,omitempty"`

	Checkout LicenseAPIRoute `json:"checkout,omitempty"`
	Portal   LicenseAPIRoute `json:"portal,omitempty"`
}

type Limit struct {
	// Name is the name of the resource (ResourceName)
	// +optional
	Name string `json:"name,omitempty"`

	// DisplayName is for display purposes.
	// +optional
	DisplayName string `json:"displayName,omitempty"`

	// Limit specifies the limit for this resource.
	// +optional
	Quantity *ResourceCount `json:"quantity,omitempty"`

	// Name of the module that this limit belongs to
	// +optional
	Module string `json:"module,omitempty"`
}

type Module struct {
	// Name of the module (ModuleName)
	Name string `json:"name"`

	// +optional
	DisplayName string `json:"displayName,omitempty"`

	// +optional
	Status FeatureStatus `json:"status,omitempty"`

	Limits   []*Limit   `json:"limits,omitempty"`
	Features []*Feature `json:"features,omitempty"`
}

type ModuleName string

type NodeInfo struct {
	MachineID         string            `json:"machine_id"`
	CreationTimestamp string            `json:"creation_timestamp"`
	Capacity          map[string]string `json:"capacity"`
}

type OfflineLicenseKeyClaims struct {
	License *License `json:"license,omitempty"`
}

type Plan struct {
	// ID of the plan
	ID string `json:"id,omitempty"`

	// DisplayName is the display name of the plan
	// +optional
	DisplayName string `json:"displayName,omitempty"`

	// Status is the status of the plan
	// There should only be 1 active plan at the top-level (not including AddOns)
	// The respective price in Prices will have the active status as well
	// +optional
	Status PlanStatus `json:"status,omitempty"`

	// Period provides information about the plan's current period
	// This is nil unless this is the active plan
	// +optional
	Period *PlanPeriod `json:"period,omitempty"`

	// Trial provides details about a planned, ongoing or expired trial
	// +optional
	Trial *Trial `json:"trial,omitempty"`

	// UpcomingInvoice provides a preview of the next invoice that will be created for this Plan
	// +optional
	UpcomingInvoice *Invoice `json:"invoice,omitempty"`

	// Features is a list of features included in the plan
	// +optional
	Features []string `json:"features,omitempty"`

	// Limits is a list of resources included in the plan and their limits
	// +optional
	Limits []Limit `json:"limits,omitempty"`

	// Prices provides details about the available prices (depending on the interval, for example)
	// +optional
	Prices []PlanPrice `json:"prices,omitempty"`

	// AddOns are plans that can be added to this plan
	// +optional
	AddOns []Plan `json:"addons,omitempty"`
}

type PlanExpiration struct {
	// ExpiresAt is the unix timestamp of when the plan expires
	// +optional
	ExpiresAt int64 `json:"expiresAt,omitempty"`

	// UpgradesTo states the name of the plan that is replacing the current one upon its expiration
	// If this is nil, then this plan just expires (i.e. the subscription may be canceled, paused, etc.)
	// +optional
	UpgradesTo *string `json:"upgradesTo,omitempty"`
}

type PlanInterval string

type PlanPeriod struct {
	// CurrentPeriodStart contains the unix timestamp marking the start of the current period
	// +optional
	CurrentPeriodStart int64 `json:"start,omitempty"`

	// CurrentPeriodEnd contains the unix timestamp marking the end of the current period
	// +optional
	CurrentPeriodEnd int64 `json:"end,omitempty"`
}

type PlanPrice struct {
	// ID of the price
	ID string `json:"id,omitempty"`

	// Status is the status of the price (PlanStatus)
	// If the plan is active, one of its prices must be active as well
	// +optional
	Status PlanStatus `json:"status,omitempty"`

	// Interval contains the time span of each period (e.g. month, year)
	// +optional
	Interval PlanInterval `json:"interval,omitempty"`

	// IntervalCount specifies if the number of intervals (e.g. 3 [months])
	// +optional
	IntervalCount float64 `json:"intervalCount,omitempty"`

	// Expiration provides information about when this plan expires
	// +optional
	Expiration *PlanExpiration `json:"exp,omitempty"`

	// Quantity sets the quantity the TierResource is supposed to be at
	// If this is the active price, then this is the subscription quantity (currently purchased quantity)
	// +optional
	Quantity float64 `json:"quantity,omitempty"`

	// TierResource provides details about the main resource the tier quantity relates to
	// This may be nil for plans that don't have their quantity tied to a resource
	// +optional
	TierResource *TierResource `json:"resource,omitempty"`

	// TierMode defines how tiers should be used
	// +optional
	TierMode TierMode `json:"tierMode,omitempty"`

	// Tiers is a list of tiers in this plan
	// +optional
	Tiers []PriceTier `json:"tiers,omitempty"`
}

type PlanStatus string

type PlatformDatabase struct {
	IsReady               bool   `json:"isReady"`
	CreationTimestamp     string `json:"creationTimestamp"`
	LatestUpdateTimestamp string `json:"latestUpdateTimestamp"`
}

type PriceTier struct {
	// MinQuantity is the quantity included in this plan
	// +optional
	MinQuantity float64 `json:"min,omitempty"`

	// MaxQuantity is the max quantity that can be purchased
	// +optional
	MaxQuantity float64 `json:"max,omitempty"`

	// UnitPrice is the price per unit in this tier
	// +optional
	UnitPrice float64 `json:"unitPrice,omitempty"`

	// FlatFee is the flat fee for this tier
	// +optional
	FlatFee float64 `json:"flatFee,omitempty"`

	// Currency specifies the currency of UnitPrice and FlatFee in 3-character ISO 4217 code
	// Default is: "" (representing USD)
	// +optional
	Currency string `json:"currency,omitempty"`
}

type ProductName string

type Request struct {
	// Group is the api group.
	// +optional
	Group string `json:"group,omitempty"`
	// Resource is the resource name for the request.
	// +optional
	Resource string `json:"resource,omitempty"`
	// Verbs is the list of verbs for the request.
	// +optional
	Verbs []string `json:"verbs,omitempty"`
}

type ResourceCount struct {
	// Active specifies the number of currently active resource (non-sleeping).
	// +optional
	Active *int64 `json:"active,omitempty"`
	// Total specifies the number of currently existing resources.
	// +optional
	Total *int64 `json:"total,omitempty"`
	// TotalCreated is a continuous counter of the amount of resources ever created.
	// +optional
	TotalCreated *int64 `json:"created,omitempty"`
	// Committed specifies the amount of resource consumption customers have committed to for a given billing period.
	// It can be exceeded and will then be charged with overage fees.
	// +optional
	Committed *int64 `json:"committed,omitempty"`
}

type ResourceName string

type ResourceStatus string

type TierMode string

type TierResource struct {
	// Name of the resource (ResourceName)
	Name string `json:"name,omitempty"`

	// Status defines which resources will be counted towards the limit (e.g. active, total, total created etc.)
	// +optional
	Status ResourceStatus `json:"status,omitempty"`
}

type Trial struct {
	// ID is the unique id of this trial
	ID string `json:"id,omitempty"`

	// DisplayName is a display name for the trial
	// +optional
	DisplayName string `json:"displayName,omitempty"`

	// Start is the unix timestamp stating when the trial was started
	// +optional
	Start *int64 `json:"start,omitempty"`

	// End is the unix timestamp stating when the trial will end or ended
	// +optional
	End int64 `json:"end,omitempty"`

	// Status is the status of this trial (TrialStatus)
	// +optional
	Status string `json:"status,omitempty"`

	// DowngradesTo states the name of the plan that is replacing the current one once the trial expires
	// If this is nil, then this plan just expires (i.e. the subscription may be canceled, paused, etc.)
	// +optional
	DowngradesTo *string `json:"downgradesTo,omitempty"`
}

type TrialStatus string

type UsageData struct {
	// FeatureUsage contains the usage of features
	FeatureUsage map[string]FeatureUsage `json:"featureUsage"`

	// ResourceUsage contains the usage of resources
	ResourceUsage map[string]ResourceCount `json:"resourceUsage"`

	// Details contains the details of the usage data
	Details UsageDataDetails `json:"details"`
}

type UsageDataDetails struct {
	// Nodes contains the details of the nodes
	Nodes []NodeInfo `json:"nodes"`

	// DevsyClusters contains the details of the virtual clusters
	DevsyClusters []DevsyClusterInfo `json:"vClusters"`
}