pluginz

type API interface {
	cloudz.Plugin
	GetConfig() *APIConfig
	GetLocalMetadata() *APILocalMetadata
	GetCloudMetadata() *APICloudMetadata
}

type APICloudMetadata struct {
	Exports cloudz.CloudExports
	// contains filtered or unexported fields
}

type APIConfig struct {
	Stage     cloudz.Stage `validate:"required"`
	Name      string       `validate:"required,resource-name"`
	RouteKeys []string     `validate:"required"`
	Local     *APIConfigLocal
	Cloud     *APIConfigCloud
}

type APIConfigCloud struct {
	DomainName string `validate:"required,fqdn"`
	CORSDomain string `validate:"required,fqdn"`
}

type APIConfigFunc func(cloudz.Stage, *APIDependencies) *APIConfig

type APIConfigLocal struct {
	ExternalPort uint16 `validate:"required"`
}

type APIDependencies struct {
	Certificate       Certificate `validate:"required"`
	Function          Function    `validate:"required"`
	OtherDependencies cloudz.OtherDependencies
}

type APILocalMetadata struct {
	ExternalURL *url.URL
	InternalURL *url.URL
}

type Bucket interface {
	cloudz.Plugin
	GetConfig() *BucketConfig
	GetLocalMetadata() *BucketLocalMetadata
	GetCloudMetadata() *BucketCloudMetadata
}

type BucketCloudMetadata struct {
	Exports cloudz.CloudExports
	// contains filtered or unexported fields
}

type BucketConfig struct {
	Stage                 cloudz.Stage `validate:"required"`
	Name                  string       `validate:"required,resource-name"`
	IsPublicAccessEnabled bool
	Local                 *BucketConfigLocal
	Cloud                 *BucketConfigCloud
}

type BucketConfigCloud struct {
	IsVersioningEnabled                   bool
	DeleteObjectsAfterDays                *uint16
	DeletePreviousObjectVersionsAfterDays *uint16
}

type BucketConfigFunc func(cloudz.Stage, *BucketDependencies) *BucketConfig

type BucketConfigLocal struct {
	ExternalPort uint16 `validate:"required"`
}

type BucketDependencies struct {
	OtherDependencies cloudz.OtherDependencies
}

type BucketLocalMetadata struct {
	ContainerName string
	BucketName    string
	AccessKey     string
	SecretKey     string
	ExternalURL   *url.URL
	InternalURL   *url.URL
}

type Certificate interface {
	cloudz.Plugin
	GetConfig() *CertificateConfig
	GetCloudMetadata() *CertificateCloudMetadata
}

type CertificateCloudMetadata struct {
	Exports cloudz.CloudExports
}

type CertificateConfig struct {
	Stage cloudz.Stage `validate:"required"`
	Name  string       `validate:"required,resource-name"`
	Cloud *CertificateConfigCloud
}

type CertificateConfigCloud struct {
	DomainName   string `validate:"required"`
	HostedZoneID string `validate:"required"`
}

type CertificateConfigFunc func(cloudz.Stage, *CertificateDependencies) *CertificateConfig

type CertificateDependencies struct {
	OtherDependencies cloudz.OtherDependencies
}

type Function interface {
	cloudz.Plugin
	GetConfig() *FunctionConfig
	GetDependencies() *FunctionDependencies
	GetLocalMetadata() *FunctionLocalMetadata
	GetCloudMetadata() *FunctionCloudMetadata
}

type FunctionBuilder interface {
	GetLocalServiceConfigVolumes(p Function, buildDirPath string) []dctypes.ServiceVolumeConfig
	LocalBeforeDeployHook(p Function, buildDirPath string)
	GetCloudRuntime(p Function) string
	BuildCloudPackage(p Function, buildDirPath string)
}

type FunctionCloudMetadata struct {
	Exports cloudz.CloudExports
}

type FunctionConfig struct {
	Stage          cloudz.Stage    `validate:"required"`
	Name           string          `validate:"required"`
	Builder        FunctionBuilder `validate:"required"`
	TimeoutSeconds uint16          `validate:"required"`
	Environment    map[string]string
	Local          *FunctionConfigLocal
	Cloud          *FunctionConfigCloud
}

type FunctionConfigCloud struct {
	Memory       int `validate:"required"`
	RolePolicies []goiam.Role_Policy
}

type FunctionConfigFunc func(cloudz.Stage, *FunctionDependencies) *FunctionConfig

type FunctionConfigLocal struct {
	ExternalPort uint16
}

type FunctionDependencies struct {
	ArtifactsBucket   Bucket `validate:"required"`
	Network           Network
	OtherDependencies cloudz.OtherDependencies
}

type FunctionLocalMetadata struct {
	ExternalURL *url.URL
	InternalURL *url.URL
}

type Hasura interface {
	cloudz.Plugin
	GetConfig() *HasuraConfig
	GetDependencies() *HasuraDependencies
	GetLocalMetadata() *HasuraLocalMetadata
	GetCloudMetadata() *HasuraCloudMetadata
	ApplyLocalMetadata()
}

type HasuraCloudMetadata struct {
	Exports cloudz.CloudExports
	// contains filtered or unexported fields
}

type HasuraConfig struct {
	Stage            cloudz.Stage `validate:"required"`
	UnauthorizedRole *string
	JWT              *HasuraConfigJWT `validate:"required"`
	Environment      map[string]string
	Local            *HasuraConfigLocal
	Cloud            *HasuraConfigCloud
}

type HasuraConfigCloud struct {
	DomainName      string `validate:"required"`
	Replicas        int    `validate:"required"`
	CPU             int    `validate:"required"`
	Memory          int    `validate:"required"`
	AdminSecret     string `validate:"required,min=16"`
	CORSDomain      *string
	EnableAllowList bool
}

type HasuraConfigFunc func(cloudz.Stage, *HasuraDependencies) *HasuraConfig

type HasuraConfigJWT struct {
	PublicKey *rsa.PublicKey `validate:"required"`
	Issuer    string         `validate:"required"`
	Audience  string         `validate:"required"`
}

type HasuraConfigLocal struct {
	ExternalPort           uint16 `validate:"required"`
	ConsoleExternalPort    uint16 `validate:"required"`
	ConsoleAPIExternalPort uint16 `validate:"required"`
	EnableAllowList        bool
}

type HasuraDependencies struct {
	Certificate       Certificate     `validate:"required"`
	ImageRepository   ImageRepository `validate:"required"`
	LoadBalancer      LoadBalancer    `validate:"required"`
	Network           Network         `validate:"required"`
	Postgres          Postgres        `validate:"required"`
	OtherDependencies cloudz.OtherDependencies
}

type HasuraLocalMetadata struct {
	ContainerName        string
	ConsoleContainerName string
	ExternalURL          *url.URL
	InternalURL          *url.URL
}

type ImageRepository interface {
	cloudz.Plugin
	GetConfig() *ImageRepositoryConfig
	GetLocalMetadata() *ImageRepositoryLocalMetadata
	GetCloudMetadata() *ImageRepositoryCloudMetadata
}

type ImageRepositoryCloudMetadata struct {
	Exports cloudz.CloudExports
}

type ImageRepositoryConfig struct {
	Stage cloudz.Stage `validate:"required"`
	Name  string       `validate:"required,resource-name"`
	Cloud *ImageRepositoryConfigCloud
}

type ImageRepositoryConfigCloud struct {
	IsScanOnPushEnabled  bool
	AreTagsMutable       bool
	TaggedImagesPolicy   *ImageRepositoryConfigTaggedImagesPolicy
	UntaggedImagesPolicy *ImageRepositoryConfigUntaggedImagesPolicy
}

type ImageRepositoryConfigFunc func(cloudz.Stage, *ImageRepositoryDependencies) *ImageRepositoryConfig

type ImageRepositoryConfigTaggedImagesPolicy struct {
	TagPrefixes  []string `validate:"required"`
	MaximumCount int      `validate:"required"`
}

type ImageRepositoryConfigUntaggedImagesPolicy struct {
	DeleteAfterDays int `validate:"required"`
}

type ImageRepositoryDependencies struct {
	OtherDependencies cloudz.OtherDependencies
}

type ImageRepositoryLocalMetadata struct {
	ImageName string
}

type LoadBalancer interface {
	cloudz.Plugin
	GetConfig() *LoadBalancerConfig
	GetDependencies() *LoadBalancerDependencies
	GetCloudMetadata() *LoadBalancerCloudMetadata
}

type LoadBalancerCloudMetadata struct {
	Exports cloudz.CloudExports
}

type LoadBalancerConfig struct {
	Stage cloudz.Stage `validate:"required"`
}

type LoadBalancerConfigFunc func(cloudz.Stage, *LoadBalancerDependencies) *LoadBalancerConfig

type LoadBalancerDependencies struct {
	Certificate       Certificate `validate:"required"`
	Network           Network     `validate:"required"`
	OtherDependencies cloudz.OtherDependencies
}

type Mailer interface {
	cloudz.Plugin
	GetConfig() *MailerConfig
	GetDependencies() *MailerDependencies
	GetLocalMetadata() *MailerLocalMetadata
}

type MailerConfig struct {
	Stage cloudz.Stage `validate:"required"`
	Local *MailerConfigLocal
}

type MailerConfigFunc func(cloudz.Stage, *MailerDependencies) *MailerConfig

type MailerConfigLocal struct {
	ExternalPort     uint16 `validate:"required"`
	SMTPExternalPort uint16 `validate:"required"`
}

type MailerDependencies struct {
	OtherDependencies cloudz.OtherDependencies
}

type MailerLocalMetadata struct {
	ContainerName string
	ExternalURL   *url.URL
	InternalURL   *url.URL
	ExternalSMTP  *MailerLocalMetadataSMTP
	InternalSMTP  *MailerLocalMetadataSMTP
}

type MailerLocalMetadataSMTP struct {
	Username string
	Password string
	Host     string
	Port     uint16
}

type Network interface {
	cloudz.Plugin
	GetConfig() *NetworkConfig
	GetCloudMetadata() *NetworkCloudMetadata
}

type NetworkCloudMetadata struct {
	Exports cloudz.CloudExports
}

type NetworkConfig struct {
	Stage cloudz.Stage `validate:"required"`
}

type NetworkConfigFunc func(cloudz.Stage, *NetworkDependencies) *NetworkConfig

type NetworkDependencies struct {
	OtherDependencies cloudz.OtherDependencies
}

type Postgres interface {
	cloudz.Plugin
	GetConfig() *PostgresConfig
	GetDependencies() *PostgresDependencies
	GetLocalMetadata() *PostgresLocalMetadata
	GetCloudMetadata() *PostgresCloudMetadata
}

type PostgresCloudMetadata struct {
	Exports cloudz.CloudExports
	// contains filtered or unexported fields
}

type PostgresConfig struct {
	Stage cloudz.Stage `validate:"required"`
	Local *PostgresConfigLocal
	Cloud *PostgresConfigCloud
}

type PostgresConfigCloud struct {
	Password            string `validate:"required,min=16"`
	AllocatedStorageGBs int    `validate:"required,min=5"`
	InstanceClass       string `validate:"required"`
}

type PostgresConfigFunc func(cloudz.Stage, *PostgresDependencies) *PostgresConfig

type PostgresConfigLocal struct {
	ExternalPort      uint16 `validate:"required"`
	AdminExternalPort uint16 `validate:"required"`
}

type PostgresDependencies struct {
	Network           Network `validate:"required"`
	OtherDependencies cloudz.OtherDependencies
}

type PostgresLocalMetadata struct {
	ContainerName    string
	ExternalURL      *url.URL
	InternalURL      *url.URL
	AdminExternalURL *url.URL
}

type PostgresProxy interface {
	cloudz.Plugin
	GetConfig() *PostgresProxyConfig
	GetCloudMetadata() *PostgresProxyCloudMetadata
}

type PostgresProxyCloudMetadata struct {
	Exports cloudz.CloudExports
}

type PostgresProxyConfig struct {
	Stage cloudz.Stage `validate:"required"`
}

type PostgresProxyConfigFunc func(cloudz.Stage, *PostgresProxyDependencies) *PostgresProxyConfig

type PostgresProxyDependencies struct {
	Network           Network  `validate:"required"`
	Postgres          Postgres `validate:"required"`
	OtherDependencies []cloudz.Plugin
}