const (
	// BackendTypeSecretsManager for AWS SecretsManager
	BackendTypeSecretsManager = "secretsManager"
	// BackendTypeParameterStore for AWS Parameter Store
	BackendTypeParameterStore = "systemManager"
)

const (

	// RuleTypeIngress represents an inbound rule
	RuleTypeIngress RuleType = "Ingress"
	// RuleTypeEgress represents an outbound rule
	RuleTypeEgress RuleType = "Egress"
	// RuleProtocolAll configures a rule to represent all types of traffic
	RuleProtocolAll = "-1"
	// RuleProtocolTCP configures a rule to represent TCP based traffic
	RuleProtocolTCP = "tcp"
	// RuleProtocolUDP configures a rule to represent UDP based traffic
	RuleProtocolUDP = "udp"
)

var ErrObjectStorageBucketNotExist = errors.New("bucket does not exist")

type AddRuleOpts struct {
	ClusterName               string
	SecurityGroupStackName    string
	SecurityGroupResourceName string
	RuleType                  RuleType
	Rule                      Rule
}

type Bucketer interface {
	// CreateBucket knows how to create a bucket
	CreateBucket(CreateBucketOpts) (bucketID string, err error)
	// DeleteBucket knows how to delete a bucket
	DeleteBucket(DeleteBucketOpts) error
	// EmptyBucket knows how to remove all content from a bucket
	EmptyBucket(EmptyBucketOpts) error
}

type Certificate struct {
	ID                     ID
	FQDN                   string
	Domain                 string
	HostedZoneID           string
	CertificateARN         string
	StackName              string
	CloudFormationTemplate []byte
}

type CertificateCloudProvider interface {
	CreateCertificate(opts CreateCertificateOpts) (*Certificate, error)
	DeleteCertificate(opts DeleteCertificateOpts) error
	DeleteCognitoCertificate(opts DeleteCognitoCertificateOpts) error
}

type CertificateService interface {
	CreateCertificate(ctx context.Context, opts CreateCertificateOpts) (*Certificate, error)
	DeleteCertificate(ctx context.Context, opts DeleteCertificateOpts) error
	DeleteCognitoCertificate(ctx context.Context, opts DeleteCognitoCertificateOpts) error
}

type Cluster struct {
	ID     ID
	Config *v1alpha5.ClusterConfig
}

type ClusterCreateOpts struct {
	ID                ID
	Cidr              string
	Version           string
	VpcID             string
	VpcPrivateSubnets []VpcSubnet
	VpcPublicSubnets  []VpcSubnet
}

type ClusterCruder interface {
	CreateCluster(context.Context, ClusterCreateOpts) (*Cluster, error)
	DeleteCluster(context.Context, ClusterDeleteOpts) error
}

type ClusterDeleteOpts struct {
	ID                 ID
	FargateProfileName string
}

type ClusterDetailer interface {
	GetClusterSecurityGroupID(context.Context, *ClusterSecurityGroupIDGetOpts) (*ClusterSecurityGroupID, error)
}

type ClusterRun interface {
	CreateCluster(opts ClusterCreateOpts) (*Cluster, error)
	DeleteCluster(opts ClusterDeleteOpts) error
}

type ClusterSecurityGroupID struct {
	Value string
}

type ClusterSecurityGroupIDGetOpts struct {
	ID ID
}

type ClusterService interface {
	ClusterCruder
	ClusterDetailer
}

type ComponentCloudProvider interface {
	CreatePostgresDatabase(opts *CreatePostgresDatabaseOpts) (*PostgresDatabase, error)
	DeletePostgresDatabase(opts *DeletePostgresDatabaseOpts) error
	CreateS3Bucket(opts *CreateS3BucketOpts) (*S3Bucket, error)
	DeleteS3Bucket(opts *DeleteS3BucketOpts) error
}

type ComponentService interface {
	CreatePostgresDatabase(ctx context.Context, opts *CreatePostgresDatabaseOpts) (*PostgresDatabase, error)
	DeletePostgresDatabase(ctx context.Context, opts *DeletePostgresDatabaseOpts) error
	CreateS3Bucket(ctx context.Context, opts *CreateS3BucketOpts) (*S3Bucket, error)
	DeleteS3Bucket(ctx context.Context, opts *DeleteS3BucketOpts) error
}

type ConfigMap struct {
	ID        ID
	Name      string
	Namespace string
	Manifest  []byte
}

type ContainerRepository struct {
	ClusterID              ID
	Name                   string
	StackName              string
	CloudFormationTemplate string
}

type ContainerRepositoryCloudProvider interface {
	CreateContainerRepository(opts *CreateContainerRepositoryOpts) (*ContainerRepository, error)
	DeleteContainerRepository(opts *DeleteContainerRepositoryOpts) error
	EmptyContainerRepository(ctx context.Context, opts EmptyContainerRepositoryOpts) error
}

type ContainerRepositoryService interface {
	CreateContainerRepository(ctx context.Context, opts *CreateContainerRepositoryOpts) (*ContainerRepository, error)
	DeleteContainerRepository(ctx context.Context, opts *DeleteContainerRepositoryOpts) error
	EmptyContainerRepository(ctx context.Context, opts EmptyContainerRepositoryOpts) error
}

type CreateBucketOpts struct {
	// ClusterID identifies which cluster to do the operation in context of
	ClusterID ID
	// BucketName defines the name of the bucket to create
	BucketName string
	// Determines if the bucket should be protected from public access. N.B.: leaving this as false does not mean public
	// access is allowed nor enabled
	Private bool
	// Encrypted defines if objects should be encrypted
	Encrypted bool
	// EnableVersioning defines if object versioning should be enabled
	EnableVersioning bool
}

type CreateCertificateOpts struct {
	ID           ID
	FQDN         string
	Domain       string
	HostedZoneID string
}

type CreateConfigMapOpts struct {
	ID        ID
	Name      string
	Namespace string
	Data      map[string]string
	Labels    map[string]string
}

type CreateContainerRepositoryOpts struct {
	ClusterID ID
	Name      string
	StackName string
}

type CreateExternalDNSKubeDeploymentOpts struct {
	ID           ID
	HostedZoneID string
	DomainFilter string
}

type CreateExternalSecretsOpts struct {
	ID       ID
	Manifest Manifest
}

type CreateHelmReleaseOpts struct {
	ID             ID
	RepositoryName string
	RepositoryURL  string
	ReleaseName    string
	Version        string
	Chart          string
	Namespace      string
	Values         []byte
}

type CreateHostedZoneOpts struct {
	ID     ID
	Domain string
	FQDN   string
	NSTTL  int64
}

type CreateIdentityPoolClientOpts struct {
	ID          ID
	UserPoolID  string
	Purpose     string
	CallbackURL string
}

type CreateIdentityPoolOpts struct {
	ID           ID
	AuthDomain   string
	AuthFQDN     string
	HostedZoneID string
}

type CreateIdentityPoolUserOpts struct {
	ID         ID
	Email      string
	UserPoolID string
}

type CreateNamespaceOpts struct {
	ID        ID
	Namespace string
	Labels    map[string]string
}

type CreatePolicyOpts struct {
	ID                     ID
	StackName              string
	PolicyOutputName       string
	CloudFormationTemplate []byte
}

type CreatePostgresDatabaseOpts struct {
	ID                ID
	ApplicationName   string
	UserName          string
	StackName         string
	VpcID             string
	DBSubnetGroupName string
	DBSubnetIDs       []string
	DBSubnetCIDRs     []string
	RotaterBucket     string
	RotaterKey        string
}

type CreateS3BucketOpts struct {
	ID               ID
	Name             string
	StackName        string
	Encrypt          bool
	EnableVersioning bool
}

type CreateSecretOpts struct {
	ID     ID
	Name   string
	Secret string
}

type CreateSecurityGroupOpts struct {
	ClusterID     ID
	VPCID         string
	Name          string
	Description   string
	InboundRules  []Rule
	OutboundRules []Rule
}

type CreateServiceAccountOpts struct {
	ID        ID
	Name      string
	PolicyArn string
	Config    *v1alpha5.ClusterConfig
}

type CreateStorageClassOpts struct {
	ID          ID
	Name        string
	Parameters  *storageclass.EBSParameters
	Annotations map[string]string
}

type CreateStoreOpts struct {
	// ClusterID identifies which cluster the store should be created in context of
	ClusterID ID
	// Name defines the name of the key / value store to create
	Name StoreName
	// Keys defines the provisioned keys the store should accept
	Keys []string
}

type CreateVpcOpts struct {
	ID      ID
	Cidr    string
	Minimal bool
}

type Data struct {
	Key      string
	Name     string
	Property string
}

type DeleteBucketOpts struct {
	// ClusterID identifies which cluster to do the operation in context of
	ClusterID ID
	// BucketName defines the name of the bucket to delete
	BucketName string
}

type DeleteCertificateOpts struct {
	ID     ID
	Domain string
}

type DeleteCognitoCertificateOpts struct {
	ID     ID
	Domain string
}

type DeleteConfigMapOpts struct {
	ID        ID
	Name      string
	Namespace string
}

type DeleteContainerRepositoryOpts struct {
	ClusterID ID
	StackName string
}

type DeleteExternalSecretsOpts struct {
	ID        ID
	Manifests map[string]string
}

type DeleteHelmReleaseOpts struct {
	ID          ID
	ReleaseName string
	Namespace   string
}

type DeleteHostedZoneOpts struct {
	ID           ID
	HostedZoneID string
	Domain       string
}

type DeleteIdentityPoolClientOpts struct {
	ID      ID
	Purpose string
}

type DeleteIdentityPoolOpts struct {
	ID         ID
	UserPoolID string
	Domain     string
}

type DeleteIdentityPoolUserOpts struct {
	ClusterID ID
	UserEmail string
}

type DeleteItemOpts struct {
	// ClusterID identifies which cluster the item should be deleted in context of
	ClusterID ID
	// TableName defines the name of the key / value store to delete an item from
	TableName StoreName
	// Field defines the field of where the key identifying the item should be queried
	Field string
	// Key defines the key identifying the item to delete
	Key string
}

type DeleteNamespaceOpts struct {
	ID        ID
	Namespace string
}

type DeleteObjectOpts struct {
	// BucketName defines the name of the bucket to do the operation in
	BucketName string
	// Path defines the path of the objcet to delete
	Path string
}

type DeletePolicyOpts struct {
	ID        ID
	StackName string
}

type DeletePostgresDatabaseOpts struct {
	ID        ID
	StackName string
}

type DeleteS3BucketOpts struct {
	ID        ID
	StackName string
}

type DeleteSecretOpts struct {
	ID   ID
	Name string
}

type DeleteSecurityGroupOpts struct {
	ClusterName string
	Name        string
}

type DeleteServiceAccountOpts struct {
	ID     ID
	Name   string
	Config *v1alpha5.ClusterConfig
}

type DeleteStoreOpts struct {
	// ClusterID identifies which cluster the store should be deleted in context of
	ClusterID ID
	// Name defines the name of the key / value store to delete
	Name StoreName
}

type DeleteVpcOpts struct {
	ID ID
}

type DomainCloudProvider interface {
	CreateHostedZone(opts CreateHostedZoneOpts) (*HostedZone, error)
	DeleteHostedZone(opts DeleteHostedZoneOpts) error
}

type DomainService interface {
	CreateHostedZone(ctx context.Context, opts CreateHostedZoneOpts) (*HostedZone, error)
	DeleteHostedZone(ctx context.Context, opts DeleteHostedZoneOpts) error
}

type EarlyTCPDemuxDisabler interface {
	DisableEarlyDEMUX(ctx context.Context, clusterID ID) error
}

type EmptyBucketOpts struct {
	// BucketName defines the name of the bucket to empty
	BucketName string
}

type EmptyContainerRepositoryOpts struct {
	Name string
}

type ExternalDNSKube struct {
	ID           ID
	HostedZoneID string
	DomainFilter string
	Manifests    map[string][]byte
}

type ExternalSecretSpecTemplate struct {
	StringData map[string]interface{}
}

type ExternalSecretsKube struct {
	ID        ID
	Name      string
	Namespace string
	Content   []byte
}

type GetHelmReleaseOpts struct {
	ClusterID   ID
	ReleaseName string
	Namespace   string
}

type GetObjectOpts struct {
	// ClusterID identifies which cluster to do the operation in context of
	ClusterID ID
	// BucketName defines the name of the bucket to do the operation in
	BucketName string
	// Path defines the path of the object to retrieve
	Path string
}

type GetSecurityGroupOpts struct {
	Name        string
	ClusterName string
}

type GetStringOpts struct {
	// ClusterID identifies which cluster to do the operation in context of
	ClusterID ID
	// TableName defines the name of the key / value store to do the operation in context of
	TableName StoreName
	// Selector defines the necessary information to identify an item in the store
	Selector ItemSelector
	// Field defines which attribute of an item to return
	Field string
}

type Helm struct {
	ID      ID
	Release *release.Release
	Chart   *helm.Chart
}

type HelmRun interface {
	CreateHelmRelease(opts CreateHelmReleaseOpts) (*Helm, error)
	DeleteHelmRelease(opts DeleteHelmReleaseOpts) error
	GetHelmRelease(opts GetHelmReleaseOpts) (*Helm, error)
}

type HelmService interface {
	CreateHelmRelease(ctx context.Context, opts CreateHelmReleaseOpts) (*Helm, error)
	DeleteHelmRelease(ctx context.Context, opts DeleteHelmReleaseOpts) error
	GetHelmRelease(ctx context.Context, opts GetHelmReleaseOpts) (*Helm, error)
}

type HostedZone struct {
	ID                     ID
	Managed                bool
	FQDN                   string
	Domain                 string
	HostedZoneID           string
	NameServers            []string
	StackName              string
	CloudFormationTemplate []byte
}

type ID struct {
	Region       string
	AWSAccountID string
	ClusterName  string
}

type IdentityManagerCloudProvider interface {
	CreateIdentityPool(certificateARN string, opts CreateIdentityPoolOpts) (*IdentityPool, error)
	CreateIdentityPoolClient(opts CreateIdentityPoolClientOpts) (*IdentityPoolClient, error)
	CreateIdentityPoolUser(opts CreateIdentityPoolUserOpts) (*IdentityPoolUser, error)
	DeleteIdentityPool(opts DeleteIdentityPoolOpts) error
	DeleteIdentityPoolClient(opts DeleteIdentityPoolClientOpts) error
	DeleteIdentityPoolUser(opts DeleteIdentityPoolUserOpts) error
}

type IdentityManagerService interface {
	CreateIdentityPool(ctx context.Context, opts CreateIdentityPoolOpts) (*IdentityPool, error)
	CreateIdentityPoolClient(ctx context.Context, opts CreateIdentityPoolClientOpts) (*IdentityPoolClient, error)
	CreateIdentityPoolUser(ctx context.Context, opts CreateIdentityPoolUserOpts) (*IdentityPoolUser, error)
	DeleteIdentityPool(ctx context.Context, opts DeleteIdentityPoolOpts) error
	DeleteIdentityPoolClient(ctx context.Context, opts DeleteIdentityPoolClientOpts) error
	DeleteIdentityPoolUser(ctx context.Context, opts DeleteIdentityPoolUserOpts) error
}

type IdentityPool struct {
	ID                      ID
	UserPoolID              string
	AuthDomain              string
	HostedZoneID            string
	StackName               string
	CloudFormationTemplates []byte
	Certificate             *Certificate
	RecordSetAlias          *RecordSetAlias
}

type IdentityPoolClient struct {
	ID                      ID
	UserPoolID              string
	Purpose                 string
	CallbackURL             string
	ClientID                string
	ClientSecret            string
	StackName               string
	CloudFormationTemplates []byte
}

type IdentityPoolUser struct {
	ID                     ID
	Email                  string
	UserPoolID             string
	StackName              string
	CloudFormationTemplate []byte
}

type InsertItemOpts struct {
	// ClusterID identifies which cluster the store exists in context of
	ClusterID ID
	// TableName defines the name of the key / value store to insert an item in
	TableName StoreName
	// Item defines the item to insert
	Item KeyValueStoreItem
}

type ItemSelector struct {
	// Key defines a key to match with a value when selecting an item
	Key string
	// Value defines the value a certain key must have which can identify an item
	Value string
}

type Itemer interface {
	Stringer
	// InsertItem defines a function that inserts a new item in a key / value store
	InsertItem(opts InsertItemOpts) error
	// RemoveItem defines a function that removes an item from a key / value store
	RemoveItem(opts DeleteItemOpts) error
}

type KeyValueStoreCloudProvider interface {
	Storer
	Itemer
}

type KeyValueStoreItem struct {
	Fields map[string]interface{}
}

type KeyValueStoreService interface {
	Storer
	Itemer
}

type KubeConfig struct {
	Path    string
	Content string
}

type KubeConfigStore interface {
	SaveKubeConfig(cfg *kubeconfig.Config) error
	GetKubeConfig(clusterName string) (*KubeConfig, error)
	DeleteKubeConfig() error
}

type KubeRun interface {
	EarlyTCPDemuxDisabler
	CreateExternalDNSKubeDeployment(opts CreateExternalDNSKubeDeploymentOpts) (*ExternalDNSKube, error)
	DeleteNamespace(opts DeleteNamespaceOpts) error
	CreateStorageClass(opts CreateStorageClassOpts) (*StorageClassKube, error)
	CreateExternalSecrets(opts CreateExternalSecretsOpts) (*ExternalSecretsKube, error)
	DeleteExternalSecrets(opts DeleteExternalSecretsOpts) error
	CreateConfigMap(opts CreateConfigMapOpts) (*ConfigMap, error)
	DeleteConfigMap(opts DeleteConfigMapOpts) error
	ScaleDeployment(opts ScaleDeploymentOpts) error
	CreateNamespace(opts CreateNamespaceOpts) (*Namespace, error)
}

type KubeService interface {
	EarlyTCPDemuxDisabler
	CreateExternalDNSKubeDeployment(ctx context.Context, opts CreateExternalDNSKubeDeploymentOpts) (*ExternalDNSKube, error)
	DeleteNamespace(ctx context.Context, opts DeleteNamespaceOpts) error
	CreateStorageClass(ctx context.Context, opts CreateStorageClassOpts) (*StorageClassKube, error)
	CreateExternalSecrets(ctx context.Context, opts CreateExternalSecretsOpts) (*ExternalSecretsKube, error)
	DeleteExternalSecrets(ctx context.Context, opts DeleteExternalSecretsOpts) error
	CreateConfigMap(ctx context.Context, opts CreateConfigMapOpts) (*ConfigMap, error)
	DeleteConfigMap(ctx context.Context, opts DeleteConfigMapOpts) error
	ScaleDeployment(ctx context.Context, opts ScaleDeploymentOpts) error
	CreateNamespace(ctx context.Context, opts CreateNamespaceOpts) (*Namespace, error)
}

type ManagedPolicy struct {
	ID                     ID
	StackName              string
	PolicyARN              string
	CloudFormationTemplate []byte
}

type ManagedPolicyCloudProvider interface {
	CreatePolicy(opts CreatePolicyOpts) (*ManagedPolicy, error)
	DeletePolicy(opts DeletePolicyOpts) error
}

type ManagedPolicyService interface {
	CreatePolicy(ctx context.Context, opts CreatePolicyOpts) (*ManagedPolicy, error)
	DeletePolicy(ctx context.Context, opts DeletePolicyOpts) error
}

type Manifest struct {
	Name        string
	Namespace   string
	Backend     string
	Annotations map[string]string
	Labels      map[string]string
	Data        []Data
	Template    ExternalSecretSpecTemplate
}

type Namespace struct {
	ID        ID
	Namespace string
	Labels    map[string]string
	Manifest  []byte
}

type ObjectStorageCloudProvider interface {
	Bucketer
	Objecter
}

type ObjectStorageService interface {
	Bucketer
	Objecter
}

type Objecter interface {
	// PutObject knows how to insert an object into a bucket
	PutObject(PutObjectOpts) error
	// GetObject knows how to retrieve an object from a bucket
	GetObject(GetObjectOpts) (io.Reader, error)
	// DeleteObject knows how to remove an object from a bucket
	DeleteObject(DeleteObjectOpts) error
}

type Parameter struct {
	ID      ID
	Name    string
	Path    string
	Version int64
	Content string
}

type ParameterCloudProvider interface {
	CreateSecret(opts CreateSecretOpts) (*SecretParameter, error)
	DeleteSecret(opts DeleteSecretOpts) error
}

type ParameterService interface {
	CreateSecret(ctx context.Context, opts CreateSecretOpts) (*SecretParameter, error)
	DeleteSecret(ctx context.Context, opts DeleteSecretOpts) error
}

type PostgresDatabase struct {
	ID                           ID
	ApplicationName              string
	UserName                     string
	StackName                    string
	AdminSecretFriendlyName      string
	EndpointAddress              string
	EndpointPort                 int
	OutgoingSecurityGroupID      string
	SecretsManagerAdminSecretARN string
	LambdaPolicyARN              string
	LambdaRoleARN                string
	LambdaFunctionARN            string
	CloudFormationTemplate       string
}

type PutObjectOpts struct {
	// ClusterID identifies which cluster to do the operation in context of
	ClusterID ID
	// BucketName defines the name of the bucket to do the operation in
	BucketName string
	// Path defines the path to the object
	Path string
	// Content defines the content of the object
	Content io.Reader
}

type RecordSetAlias struct {
	AliasDomain            string
	AliasHostedZones       string
	StackName              string
	CloudFormationTemplate []byte
}

type RemoveRuleOpts struct {
	ClusterName               string
	SecurityGroupStackName    string
	SecurityGroupResourceName string
	RuleType                  RuleType
	Rule                      Rule
}

type Rule struct {
	Description           string `json:"Description"`
	FromPort              int    `json:"FromPort"`
	ToPort                int    `json:"ToPort"`
	CidrIP                string `json:"CidrIp,omitempty"`
	Protocol              string `json:"IpProtocol"`
	SourceSecurityGroupID string `json:"SourceSecurityGroupId,omitempty"`
}

type RuleType string

type S3Bucket struct {
	ID                     ID
	Name                   string
	StackName              string
	CloudFormationTemplate string
}

type ScaleDeploymentOpts struct {
	ID        ID
	Name      string
	Namespace string
	Replicas  int32
}

type SecretParameter struct {
	Parameter
}

type SecurityGroup struct {
	ID            string
	InboundRules  []Rule
	OutboundRules []Rule
}

type SecurityGroupCRUDer interface {
	CreateSecurityGroup(ctx context.Context, opts CreateSecurityGroupOpts) (SecurityGroup, error)
	GetSecurityGroup(ctx context.Context, opts GetSecurityGroupOpts) (SecurityGroup, error)
	DeleteSecurityGroup(ctx context.Context, opts DeleteSecurityGroupOpts) error
}

type SecurityGroupCloudProvider interface {
	SecurityGroupCRUDer
	SecurityGroupRuleCRUDer
}

type SecurityGroupRuleCRUDer interface {
	AddRule(ctx context.Context, opts AddRuleOpts) (Rule, error)
	RemoveRule(ctx context.Context, opts RemoveRuleOpts) error
}

type SecurityGroupService interface {
	SecurityGroupCRUDer
	SecurityGroupRuleCRUDer
}

type ServiceAccount struct {
	ID        ID
	Name      string
	PolicyArn string
	Config    *v1alpha5.ClusterConfig
}

type ServiceAccountRun interface {
	CreateServiceAccount(*v1alpha5.ClusterConfig) error
	DeleteServiceAccount(*v1alpha5.ClusterConfig) error
}

type ServiceAccountService interface {
	CreateServiceAccount(ctx context.Context, opts CreateServiceAccountOpts) (*ServiceAccount, error)
	DeleteServiceAccount(ctx context.Context, opts DeleteServiceAccountOpts) error
}

type StorageClassKube struct {
	ID       ID
	Name     string
	Manifest []byte
}

type StoreName string

type Storer interface {
	// CreateStore defines a function that creates a key / value store
	CreateStore(CreateStoreOpts) error
	// DeleteStore defines a function that deletes a key / value store
	DeleteStore(DeleteStoreOpts) error
	// ListStores defines a function that lists all available stores
	ListStores() ([]string, error)
}

type Stringer interface {
	// GetString defines a function that retrieves a string from a key / value store
	GetString(opts GetStringOpts) (string, error)
}

type Vpc struct {
	ID                     ID
	StackName              string
	CloudFormationTemplate []byte

	VpcID                    string
	Cidr                     string
	PublicSubnets            []VpcSubnet
	PrivateSubnets           []VpcSubnet
	DatabaseSubnets          []VpcSubnet
	DatabaseSubnetsGroupName string
}

type VpcCloudProvider interface {
	CreateVpc(opts CreateVpcOpts) (*Vpc, error)
	DeleteVpc(opts DeleteVpcOpts) error
}

type VpcService interface {
	CreateVpc(ctx context.Context, opts CreateVpcOpts) (*Vpc, error)
	DeleteVpc(ctx context.Context, opts DeleteVpcOpts) error
}

type VpcSubnet struct {
	ID               string
	Cidr             string
	AvailabilityZone string
}