types

type BadRequest struct {
	Message string `json:"message"`
	Code    string `json:"code"`
}

type Build struct {
	// ID is the ID of the build.
	ID string `json:"id"`

	// DeploymentID is the ID of the deployment that this build is for.
	DeploymentID string `json:"deployment_id"`

	// Metadata is the metadata for the build. This can be nil.
	Metadata *BuildMetadata `json:"metadata"`

	// Method is the method used to build the container.
	Method BuildMethod `json:"method"`

	// StartedAt is the time that the build was started at. Is nil for no value.
	StartedAt *Timestamp `json:"started_at"`

	// FinishedAt is the time that the build finished at. Is nil for no value.
	FinishedAt *Timestamp `json:"finished_at"`

	// State is the state of the build.
	State BuildState `json:"state"`

	// Digest is the digest for the image. Can be blank for no value.
	Digest string `json:"digest"`

	// Environment is information about the build environment.
	Environment BuildEnvironment `json:"environment"`

	// ValidationFailure is set when the build state is failed.
	ValidationFailure *BuildValidationFailure `json:"validation_failure"`
}

type BuildAuthor struct {
	// AvatarURL is the URL of the avatar of the author. This can be blank.
	AvatarURL string `json:"avatar_url"`

	// Username is the username of the author.
	Username string `json:"username"`
}

type BuildCmds struct {
	// Build is the command used for builds. Can be nil.
	Build *string `json:"build"`

	// Start is the command used for starting the container. Can be nil.
	Start *string `json:"start"`

	// Install is the command used for installing the container. Can be nil.
	Install *string `json:"install"`
}

type BuildEnvironment struct {
	// Language is the language this was built with. Can be nil.
	Language *string `json:"language"`

	// Cmds are the commands that were invoked during the build.
	Cmds BuildCmds `json:"cmds"`
}

type BuildMetadata struct {
	// AccountType is the type of account that triggered the build. This can be blank.
	AccountType string `json:"account_type"`

	// Author is the author of the build. This can be nil.
	Author *BuildAuthor `json:"author"`

	// RepoID is the ID of the repository that the build was triggered from.
	RepoID int `json:"repo_id"`

	// RepoName is the name of the repository that the build was triggered from.
	RepoName string `json:"repo_name"`

	// Branch is the branch that the build was triggered from.
	Branch string `json:"branch"`

	// CommitSHA is the SHA of the commit that the build was triggered from.
	CommitSHA string `json:"commit_sha"`

	// CommitMessage is the message of the commit that the build was triggered from.
	CommitMessage string `json:"commit_msg"`

	// CommitURL is the URL of the commit that the build was triggered from. This can be blank.
	CommitURL string `json:"commit_url"`
}

type BuildMethod string

type BuildState string

type BuildValidationFailure struct {
	// Reason is the reason that the validation failed.
	Reason string `json:"reason"`

	// HelpLink is used to define a help link if present. Can be nil.
	HelpLink *string `json:"help_link"`
}

type Channel struct {
	ChannelPartial `json:",inline"`

	// Project is the project it is associated with.
	Project *Project `json:"project"`

	// Capabilities is the capabilities of this channel.
	Capabilities int `json:"capabilities"`

	// CreatedAt is when this channel was created.
	CreatedAt Timestamp `json:"created_at"`
}

type ChannelPartial struct {
	// ID is the ID of the channel.
	ID string `json:"id"`

	// State is any state metadata associated with the channel.
	State map[string]any `json:"state"`

	// Type is the type of this channel.
	Type ChannelType `json:"type"`
}

type ChannelToken struct {
	// ID is the ID of the token.
	ID string `json:"id"`

	// State is any state metadata associated with the token.
	State map[string]any `json:"state"`

	// ProjectID is the project ID associated with the token.
	ProjectID string `json:"project_id"`

	// IsOnline is whether the token is online (e.g.: active heartbeat and connected to leap).
	IsOnline bool `json:"is_online"`
}

type ChannelType string

type Container struct {
	// ID is the ID of the container.
	ID string `json:"id"`

	// CreatedAt defines when this container was created.
	CreatedAt Timestamp `json:"created_at"`

	// Region is the region that this container is running in.
	Region Region `json:"region"`

	// Uptime is used to define uptime/downtime information for this container.
	Uptime ContainerUptime `json:"uptime"`

	// Type is the runtime type of this container.
	Type RuntimeType `json:"type"`

	// InternalIP is the internal IP address of this container.
	InternalIP string `json:"internal_ip"`

	// DeploymentID is the ID of the deployment that this container is a part of.
	DeploymentID string `json:"deployment_id"`

	// State is the state of this container.
	State ContainerState `json:"state"`

	// Metadata is the metadata for this container.
	Metadata ContainerMetadata `json:"metadata"`

	// Volume is the volume definition for this container. This can be nil.
	Volume *VolumeDefinition `json:"volume"`

	// Metrics is used to define the container metrics. This can be nil.
	Metrics *ContainerMetrics `json:"metrics"`

	// Overrides is used to define overrides that were provided manually to the container.
	// Items in Resources can be empty if they are unset, or overrides can be nil.
	Overrides *Resources `json:"overrides"`
}

type ContainerBuildSettings struct {
	// RootDirectory is used to define the root directory for the container build. Can be blank.
	RootDirectory string `json:"root_directory"`
}

type ContainerLog struct {
	// Timestamp is the timestamp of the log message.
	Timestamp Timestamp `json:"timestamp"`

	// Message is the log message.
	Message string `json:"message"`

	// Nonce is the ID of the document in Elasticsearch. This can be safely used to map state.
	Nonce string `json:"nonce"`

	// Level is the logging level.
	Level LoggingLevel `json:"level"`
}

type ContainerMetadata struct {
	// LastExitCode is used to define the last exit code of the container. It is nil if the container has never exited.
	LastExitCode *int `json:"last_exit_code"`
}

type ContainerMetrics struct {
	// CPUUsagePercent is used to define the % usage of the CPU.
	CPUUsagePercent float64 `json:"cpu_usage_percent"`

	// MemoryUsagePercent is used to define the % usage of the RAM.
	MemoryUsagePercent float64 `json:"memory_usage_percent"`

	// MemoryUsageBytes is the number of bytes of memory currently being used.
	MemoryUsageBytes uint32 `json:"memory_usage_bytes"`
}

type ContainerState string

type ContainerStrategy string

type ContainerUptime struct {
	// LastStart is the last time the container was started.
	LastStart Timestamp `json:"last_start"`
}

type DefaultQuotas struct {
	VCPU float64 `json:"vcpu"`
	RAM  float64 `json:"ram"`
}

type DeliveryProtocol string

type Deployment struct {
	// ID is the ID of the deployment.
	ID string `json:"id"`

	// Name is the name of the deployment.
	Name string `json:"name"`

	// TargetContainerCount is the number of expected containers.
	TargetContainerCount int `json:"target_container_count"`

	// ContainerCount is the number of containers that are currently running.
	ContainerCount int `json:"container_count"`

	// CreatedAt defines when this deployment was created.
	CreatedAt Timestamp `json:"created_at"`

	// Config is the configuration for this deployment.
	Config DeploymentConfigPartial `json:"config"`

	// ActiveRollout is the rollout for this deployment. Can be nil if not defined.
	//
	// Deprecated: Use LatestRollout instead.
	ActiveRollout *DeploymentRollout `json:"active_rollout"`

	// LatestRollout is the rollout for this deployment. Can be nil if not defined.
	LatestRollout *DeploymentRollout `json:"latest_rollout"`

	// ActiveBuild is the build for this deployment. Can be nil if not defined.
	ActiveBuild *Build `json:"active_build"`

	// Metadata is used to define any deployment metadata. Can be nil if not defined.
	Metadata *DeploymentMetadata `json:"metadata"`

	// RunningContainerCount is the amount of containers in the running state.
	RunningContainerCount int `json:"running_container_count"`

	// BuildCacheEnabled is used to define if the build cache is enabled.
	BuildCacheEnabled bool `json:"build_cache_enabled"`

	// BuildSettings is used to define the build settings for a container.
	BuildSettings *ContainerBuildSettings `json:"build_settings"`
}

type DeploymentConfig struct {
	// DeploymentConfigPartial is the partial configuration of a deployment that this is based on.
	DeploymentConfigPartial `json:",inline"`

	// Name is the name of the deployment.
	Name string `json:"name"`

	// Volume is the volume that this deployment is using. This can only be used when Type is RuntimeTypeStateful.
	Volume *VolumeDefinition `json:"volume,omitempty"`
}

type DeploymentConfigPartial struct {
	// ContainerStrategy is the strategy used to scale a container.
	ContainerStrategy ContainerStrategy `json:"container_strategy"`

	// Type is used to define the type of this deployment.
	Type RuntimeType `json:"type"`

	// Version is the version of the deployment.
	Version string `json:"version"`

	// Image is the Docker image config for this deployment.
	Image Image `json:"image"`

	// Env is the environment variables for this deployment.
	Env map[string]string `json:"env"`

	// Resources is the resources for this deployment.
	Resources Resources `json:"resources"`

	// RestartPolicy is the restart policy for this deployment.
	RestartPolicy RestartPolicy `json:"restart_policy"`

	// Entrypoint is used to define the entrypoint for the application. Can be nil.
	Entrypoint []string `json:"entrypoint"`

	// Cmd is used to define the cmd for the application. Can be nil.
	Cmd []string `json:"cmd"`
}

type DeploymentMetadata struct {
	// ContainerPortMappings is used to map the containers to ports.
	ContainerPortMappings map[string][]string `json:"container_port_mappings"`
}

type DeploymentRollout struct {
	// Count is the number of containers which are being recreated.
	Count int `json:"count"`

	// CreatedAt is the time that the rollout was created at.
	CreatedAt Timestamp `json:"created_at"`

	// DeploymentID is the ID of the deployment that this rollout is for.
	DeploymentID string `json:"deployment_id"`

	// ID is the ID of the rollout.
	ID string `json:"id"`

	// State is the state of the rollout.
	State RolloutState `json:"status"`

	// Build is the build that this rollout is for. This can be nil.
	Build *Build `json:"build"`

	// Acknowledged is used to define if the rollout has been acknowledged by the user.
	Acknowledged bool `json:"acknowledged"`

	// InitContainerID is the container ID this rollout is portioning to. This can be blank.
	InitContainerID string `json:"init_container_id"`

	// HealthCheckFailed is used to define if the health check failed.
	HealthCheckFailed bool `json:"health_check_failed"`

	// LastUpdatedAt is the time that the rollout was last updated at.
	LastUpdatedAt Timestamp `json:"last_updated_at"`
}

type DeploymentStorageInfo struct {
	// Volume is used to define the storage information. Can be nil.
	Volume *DeploymentStorageSize `json:"volume"`

	// BuildCache is used to define the build cache storage information. Can be nil.
	BuildCache *DeploymentStorageSize `json:"build_cache"`
}

type DeploymentStorageSize struct {
	// ProvisionedSize is the amount of storage in MB that is provisioned.
	ProvisionedSize int `json:"provisioned_size"`

	// UsedSize is the amount of storage in MB that is used for the build cache.
	UsedSize int `json:"used_size"`
}

type DockerAuth struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

type Domain struct {
	// ID is the ID of the domain.
	ID string `json:"id"`

	// Domain is the full name of the domain.
	Domain string `json:"domain"`

	// State is the state of the domain.
	State DomainState `json:"state"`

	// CreatedAt defines when this domain was created.
	CreatedAt Timestamp `json:"created_at"`

	// Redirect is where the domain can redirect. Can be nil if no redirect is configured.
	Redirect *DomainRedirect `json:"redirect"`
}

type DomainRedirect struct {
	// URL is the URL to redirect to.
	URL string `json:"url"`

	// StatusCode is the status code to use for the redirect.
	StatusCode int `json:"status_code"`
}

type DomainState string

type GPUType string

type Gateway struct {
	// ID is used to define the ID of a gateway.
	ID string `json:"id"`

	// Type is the type of the gateway.
	Type GatewayType `json:"type"`

	// Name is the name of the gateway.
	Name string `json:"name"`

	// Protocol is the protocol of the gateway. This is only used on external gateways. This will be blank on internal gateways.
	Protocol GatewayProtocol `json:"protocol"`

	// DeploymentID is the ID of the deployment that this gateway is attached to.
	DeploymentID string `json:"deployment_id"`

	// CreatedAt defines when this gateway was created.
	CreatedAt Timestamp `json:"created_at"`

	// HopshDomain is the hop.sh domain that this gateway is automatically assigned. This will be blank if none is assigned.
	HopshDomain string `json:"hopsh_domain"`

	// HopshDomainEnabled determines if the hop.sh domain is currently active.
	HopshDomainEnabled bool `json:"hopsh_domain_enabled"`

	// InternalDomain is the internal domain that this gateway is automatically assigned. This will be blank if none is assigned.
	InternalDomain string `json:"internal_domain"`

	// TargetPort is the port that this gateway is targeting. This will be nil if none is assigned.
	TargetPort *int `json:"target_port"`

	// Domains is the list of domains that this gateway is assigned to.
	Domains []*Domain `json:"domains"`
}

type GatewayCreationOptions struct {
	// DeploymentID is the ID of the deployment that this gateway is for.
	DeploymentID string `json:"-"`

	// Name is the name of the gateway.
	Name string `json:"name"`

	// Type is the type of gateway to create, either internal or external.
	Type GatewayType `json:"type"`

	// Protocol is the protocol to use for the gateway.
	Protocol GatewayProtocol `json:"protocol"`

	// TargetPort is the port to listen on.
	TargetPort int `json:"target_port"`

	// InternalDomain is used when the gateway type is internal.
	InternalDomain string `json:"internal_domain,omitempty"`

	// ProjectID is the ID of the project that this gateway is for. Can be blank if using a project token.
	//
	// Deprecated: Set the project ID with client options instead.
	ProjectID string `json:"-"`
}

type GatewayProtocol string

type GatewayType string

type HLSConfig struct {
	WCLDelay                int    `json:"wcl_delay"`
	ArtificialDelay         int    `json:"artificial_delay"`
	MaxPlayoutBitratePreset string `json:"max_playout_bitrate_preset"`
}

type HealthCheck struct {
	// Inlines the options since they are also used here.
	HealthCheckCreateOpts `json:",inline"`

	// ID defines the ID of the health check.
	ID string `json:"id"`

	// CreatedAt defines when the health check was created.
	CreatedAt Timestamp `json:"created_at"`

	// Type defines the type of the health check.
	Type HealthCheckType `json:"type"`
}

type HealthCheckCreateOpts struct {
	// DeploymentID is used to define the ID of the deployment. This must be set.
	DeploymentID string `json:"deployment_id,omitempty"`

	// Protocol is the protocol that this health check will work on. If blank, will default to "http".
	Protocol HealthCheckProtocol `json:"protocol"`

	// Path is the path which should be hit for the health check. If blank, will default to "/".
	Path string `json:"path"`

	// Port is the port that should be hit for the health check. If blank, will default to 8080.
	Port int `json:"port"`

	// InitialDelay is the initial delay in health checking. If blank, will default to 5 seconds.
	InitialDelay Seconds `json:"initial_delay"`

	// Interval is the interval between health checks in seconds. If blank, will default to 1 minute.
	Interval Seconds `json:"interval"`

	// Timeout is used to define the timeout in milliseconds. If blank, will default to 50ms.
	Timeout Milliseconds `json:"timeout"`

	// MaxRetries is the maximum number of allowed retries before it is declared unhealthy. If blank, will default to 3.
	MaxRetries int `json:"max_retries"`
}

type HealthCheckProtocol string

type HealthCheckState struct {
	// DeploymentID defines the deployment ID this relates to.
	DeploymentID string `json:"deployment_id"`

	// ContainerID defines the container ID this relates to.
	ContainerID string `json:"container_id"`

	// HealthCheckID is used to define the ID of the health check this relates to.
	HealthCheckID string `json:"health_check_id"`

	// State is used to define the health check status.
	State HealthCheckStatus `json:"state"`

	// NextCheck defines the timestamp of the next check.
	NextCheck Timestamp `json:"next_check"`

	// CreatedAt defines when this health check was created.
	CreatedAt Timestamp `json:"created_at"`
}

type HealthCheckStatus string

type HealthCheckType string

type HealthCheckUpdateOpts struct {
	// DeploymentID is used to define the ID of the deployment. This must be set.
	DeploymentID string `json:"-"`

	// HealthCheckID is used to define the ID of the health check. This must be set.
	HealthCheckID string `json:"-"`

	// Protocol is the protocol that this health check will work on.
	Protocol HealthCheckProtocol `json:"protocol,omitempty"`

	// Path is the path which should be hit for the health check.
	Path string `json:"path,omitempty"`

	// Port is the port that should be hit for the health check.
	Port int `json:"port,omitempty"`

	// InitialDelay is the initial delay in health checking.
	InitialDelay Seconds `json:"initial_delay,omitempty"`

	// Interval is the interval between health checks in seconds.
	Interval Seconds `json:"interval,omitempty"`

	// Timeout is used to define the timeout in milliseconds.
	Timeout Milliseconds `json:"timeout,omitempty"`

	// MaxRetries is the maximum number of allowed retries before it is declared unhealthy.
	MaxRetries int `json:"max_retries,omitempty"`
}

type IgniteDeploymentUpdateOpts struct {
	// Name is the name of the deployment. If this is not blank, it will be updated.
	Name string `json:"name,omitempty"`

	// Image is the image to use for the deployment. If this is not nil, it will be updated.
	Image *Image `json:"image,omitempty"`

	// RestartPolicy is the restart policy for the deployment. If this is not blank, it will be updated.
	RestartPolicy RestartPolicy `json:"restart_policy,omitempty"`

	// ContainerStrategy is the container strategy for the deployment. If this is not blank, it will be updated.
	ContainerStrategy ContainerStrategy `json:"container_strategy,omitempty"`

	// Type is the runtime type for the deployment. If this is not blank, it will be updated.
	Type RuntimeType `json:"type,omitempty"`

	// Resources is the resources for the deployment. If this is not nil, it will be updated.
	Resources *Resources `json:"resources,omitempty"`
}

type IgniteGatewayUpdateOpts struct {
	// Name is the name of the gateway. If this is not blank, it will be updated.
	Name string `json:"name,omitempty"`

	// TargetPort is the port to listen on. If this is not 0, it will be updated.
	TargetPort int `json:"target_port,omitempty"`

	// Protocol is the protocol to use for the gateway. If this is not blank, it will be updated.
	Protocol GatewayProtocol `json:"protocol,omitempty"`
}

type Image struct {
	// Name is the name of the image. Will be blank if there's no image name.
	Name string `json:"name"`

	// Auth is the authentication information for the image. Will be nil if there's no authentication information.
	Auth *DockerAuth `json:"auth"`

	// GithubRepo is the GitHub repository that this image is from. Will be nil if there's no GitHub repository.
	GithubRepo *ImageGHInfo `json:"github_repo"`
}

type ImageDigest struct {
	Digest   string `json:"digest"`
	Size     int    `json:"size"`
	Uploaded string `json:"uploaded"`
}

type ImageGHInfo struct {
	RepoID   int    `json:"repo_id"`
	FullName string `json:"full_name"`
	Branch   string `json:"branch"`
}

type ImageManifest struct {
	// Digest is the digest of the image.
	Digest ImageDigest `json:"digest"`

	// Tag is used to define an image tag.
	Tag *string `json:"tag"`
}

type IngestProtocol string

type InvalidToken string

type LeapAuthorizationError struct {
	Data string
}

type LeapAvailableEvent struct {
	LeapDispatchEventDetails `json:",inline"`

	// Channel is the channel that is available.
	Channel *ChannelPartial `json:"channel"`
}

type LeapChannelEvent any

type LeapChannelStateUpdateEvent struct {
	LeapDispatchEventDetails `json:",inline"`

	// State is the state of the channel.
	State map[string]any `json:"state"`
}

type LeapConnectionState string

type LeapDispatchEventDetails struct {
	// ChannelID is the ID of the channel.
	ChannelID string `json:"c"`

	// Unicast is if the dispatch event was dispatched via unicast.
	Unicast bool `json:"u"`
}

type LeapInitEvent struct {
	LeapDispatchEventDetails `json:",inline"`

	// ConnectionID is the ID of the connection.
	ConnectionID string `json:"cid"`

	// Metadata is the metadata of the connection if applicable.
	Metadata map[string]any `json:"metadata"`

	// Scope is the scope of the connection.
	Scope LeapScope `json:"scope"`

	// Channels is the channels the connection is subscribed to.
	Channels []*ChannelPartial `json:"channels"`
}

type LeapMessageEvent struct {
	LeapDispatchEventDetails `json:",inline"`

	// Data is the user provided event data for the message.
	Data map[string]any `json:"d"`

	// EventName is the name of the event.
	EventName string `json:"e"`
}

type LeapPipeRoomAvailableEvent struct {
	LeapDispatchEventDetails `json:",inline"`

	// PipeRoom is the pipe room that is available.
	PipeRoom Room `json:"pipe_room"`

	// Connection is a map that contains the connection information. Everything inside will be nil if the room is offline.
	Connection PipeConnectionMap `json:"connection"`
}

type LeapPipeRoomUpdateEvent LeapPipeRoomAvailableEvent

type LeapScope string

type LeapStateInfo struct {
	// ConnectionState is the string representation of the connection state.
	ConnectionState LeapConnectionState

	// Err is set if the connection state is errored to define the error that triggered this.
	Err error

	// WillReconnect is set if the connection state is errored to define if a reconnection will be attempted.
	WillReconnect bool
}

type LeapUnavailableEvent struct {
	LeapDispatchEventDetails `json:",inline"`

	// Graceful is if the channel was gracefully unavailable.
	Graceful bool `json:"graceful"`

	// ErrorCode is the error code of the channel.
	ErrorCode string `json:"error_code"`
}

type LoggingLevel string

type Milliseconds time.Duration

type NotAuthorized string

type NotFound struct {
	// Code gives you the error code, allowing you to differentiate errors.
	Code string `json:"code"`

	// Message is the message from the Hop SDK.
	Message string `json:"message"`
}

type PipeConnection struct {
	EdgeEndpoint string           `json:"edge_endpoint"`
	Type         DeliveryProtocol `json:"type"`
	ServingPOP   string           `json:"serving_pop"`
}

type PipeConnectionMap struct {
	WebRTC *PipeConnection `json:"webrtc"`
	LLHLS  *PipeConnection `json:"llhls"`
}

type PresetForm struct {
	// Version is used to define the version of the form.
	Version uint `json:"v"`

	// Fields is used to define the form fields.
	Fields []PresetFormField `json:"fields"`
}

type PresetFormField struct {
	// Input is used to define the input information. Cannot be nil.
	// When unmarshalled, will be a pointer to a input type that
	// implements this interface.
	Input PresetFormInput `json:"input"`

	// Title is used to define the title of the form field.
	Title string `json:"title"`

	// Required is used to define if the form field is required.
	Required bool `json:"required"`

	// MapTo is used to define a map of mappings. Cannot be nil.
	MapTo []PresetFormMapTo `json:"map_to"`
}

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

type PresetFormInputAutogen string

type PresetFormInputRange struct {
	// Default is used to define the default content. Can be blank.
	Default *int `json:"default,omitempty"`

	// Min is the minimum number in the range.
	Min int `json:"min"`

	// Max is the maximum number in the range.
	Max int `json:"max"`

	// Increment is the number to increment by.
	Increment *int `json:"increment,omitempty"`

	// Unit is the unit to use.
	Unit *string `json:"unit"`
}

type PresetFormInputString struct {
	// Default is used to define the default content. Can be blank.
	Default string `json:"default,omitempty"`

	// Autogen defines the auto-generated value for this input.
	// Can be blank if unset.
	Autogen PresetFormInputAutogen `json:"autogen,omitempty"`

	// MaxLength is the maximum length of the string.
	MaxLength *uint `json:"max_length,omitempty"`

	// Validator is used to define the validator.
	Validator string `json:"validator,omitempty"`
}

type PresetFormMapTo struct {
	// Type is used to define the mapping type. Must be env.
	Type PresetFormMappingType `json:"type"`

	// Key is used to define the key this maps to. This should be blank when
	// the type is volume size.
	Key string `json:"key,omitempty"`
}

type PresetFormMappingType string

type Project struct {
	// ID is used to define the ID of a project.
	ID string `json:"id"`

	// Name is the name of a project.
	Name string `json:"name"`

	// Tier is the tier of this project.
	Tier ProjectTier `json:"tier"`

	// CreatedAt defines when this project was created.
	CreatedAt Timestamp `json:"created_at"`

	// Icon is used to define the icon for this project.
	Icon *string `json:"icon"`

	// Namespace is the registry namespace for this project.
	Namespace string `json:"namespace"`

	// Type is the type of the project.
	Type ProjectType `json:"type"`

	// DefaultQuotas is used to define the default quotas for this project.
	DefaultQuotas DefaultQuotas `json:"default_quotas"`

	// QuotaOverrides is used to define any overrides to quotas.
	QuotaOverrides map[string]int `json:"quota_overrides"`

	// QuotaUsage is the quota usage for this project.
	QuotaUsage QuotaUsage `json:"quota_usage"`
}

type ProjectMember struct {
	// ID is the ID of the member.
	ID string `json:"id"`

	// Name is the name of the member.
	Name string `json:"name"`

	// Username is the username of the member.
	Username string `json:"username"`

	// Role is the role of the member.
	Role ProjectRole `json:"role"`

	// JoinedAt is when the member joined the project.
	JoinedAt Timestamp `json:"joined_at"`
}

type ProjectPermission string

type ProjectRole struct {
	// ID is the ID of the role.
	ID string `json:"id"`

	// Name is the name of the role.
	Name string `json:"name"`

	// Flags is the flags for this role.
	Flags string `json:"flags"`
}

type ProjectSecret struct {
	// ID is the ID of the secret.
	ID string `json:"id"`

	// Name is the name of the secret.
	Name string `json:"name"`

	// Digest is the string hash of the secret.
	Digest string `json:"digest"`

	// CreatedAt is when the secret was created.
	CreatedAt Timestamp `json:"created_at"`
}

type ProjectTier string

type ProjectToken struct {
	// ID is the ID of the project token.
	ID string `json:"id"`

	// Token is part of the key value. This will likely have half of the key obfuscated.
	Token string `json:"token"`

	// CreatedAt is when this project token was created.
	CreatedAt Timestamp `json:"created_at"`
}

type ProjectType string

type QuotaUsage struct {
	VCPU float64 `json:"vcpu"`
	RAM  float64 `json:"ram"`
}

type Region string

type Resources struct {
	VCPU float64 `json:"vcpu"`
	RAM  Size    `json:"ram"`
	VGPU []VGPU  `json:"vgpu"`
}

type RestartPolicy string

type RolloutState string

type Room struct {
	// ID is the ID of the room.
	ID string `json:"id"`

	// Name is the name of the room.
	Name string `json:"name"`

	// CreatedAt is when this room was created.
	CreatedAt Timestamp `json:"created_at"`

	// IngestProtocol is the protocol you can stream with.
	IngestProtocol IngestProtocol `json:"ingest_protocol"`

	// DeliveryProtocols are the protocols that are supported by this room to the client.
	DeliveryProtocols []DeliveryProtocol `json:"delivery_protocols"`

	// JoinToken is the token to subscribe to this room.
	JoinToken string `json:"join_token"`

	// IngestRegion is the region that the stream URL is located in.
	IngestRegion Region `json:"ingest_region"`

	// State is the current state of the room.
	State RoomState `json:"state"`
}

type RoomCreationOptions struct {
	// Name is the name of the room.
	Name string `json:"name"`

	// DeliveryProtocols are the protocols that are supported by this room to the client.
	DeliveryProtocols []DeliveryProtocol `json:"delivery_protocols"`

	// Ephemeral defines whether the room is ephemeral or not.
	Ephemeral bool `json:"ephemeral"`

	// Region is used to define the room region.
	Region Region `json:"region"`

	// IngestProtocol is the protocol you can stream with.
	IngestProtocol IngestProtocol `json:"ingest_protocol"`

	// HLSConfig is the configuration for HLS delivery. This can be nil.
	HLSConfig HLSConfig `json:"llhls_config"`
}

type RoomState string

type RuntimeType string

type Seconds time.Duration

type SelfUser struct {
	User `json:",inline"`

	// EmailVerified is set to true if the user has verified their email.
	EmailVerified bool `json:"email_verified"`

	// TOTPEnabled is set to true if the user has enabled TOTP authentication.
	TOTPEnabled bool `json:"totp_enabled"`

	// WebauthnEnabled is set to true if the user hss enabled webauthn authentication.
	WebauthnEnabled bool `json:"webauthn_enabled"`

	// MFAEnabled is set to true if the user has enabled MFA.
	MFAEnabled bool `json:"mfa_enabled"`

	// Admin defines if the user is an admin.
	Admin bool `json:"admin"`
}

type ServerError string

type Size string

type Stats struct {
	OnlineCount int `json:"online_count"`
}

type Timestamp string

type UnknownServerError struct {
	StatusCode int    `json:"status_code"`
	Message    string `json:"message"`
	Code       string `json:"code"`
}

type User struct {
	// ID is the ID of the user.
	ID string `json:"id"`

	// Name is the name of the user.
	Name string `json:"name"`

	// Username is the username of the user.
	Username string `json:"username"`

	// Email is the email of the user.
	Email string `json:"email"`
}

type UserMeInfo struct {
	// Projects is the list of projects the user is a member of.
	Projects []*Project `json:"projects"`

	// User is the user.
	User SelfUser `json:"user"`

	// ProjectMemberRoleMap is a map of project ID to project member role.
	ProjectMemberRoleMap map[string]*ProjectRole `json:"project_member_role_map"`

	// LeapToken is the users Leap token. Can be blank.
	LeapToken string `json:"leap_token"`
}

type UserPat struct {
	// ID is the ID of the personal access token.
	ID string `json:"id"`

	// Name is the name of the personal access token.
	Name string `json:"name"`

	// PAT is a partially censored personal access token (unless this is from a creation).
	PAT string `json:"pat"`

	// CreatedAt is when the personal access token was created.
	CreatedAt Timestamp `json:"created_at"`
}

type VGPU struct {
	// Type is the type of the virtual GPU.
	Type GPUType `json:"type"`

	// Count is the number of GPU's to allocate of this type.
	Count int `json:"count"`
}

type ValidationError struct {
	Errors []gojsonschema.ResultError `json:"errors"`
}

type VolumeDefinition struct {
	// FS is the filesystem of the volume.
	FS VolumeFormat `json:"fs"`

	// Size is the size of the volume.
	Size Size `json:"size"`

	// MountPath is the mount path of the volume.
	MountPath string `json:"mountpath"`
}

type VolumeFormat string