hyperdrive

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 ConfigDeleteParams struct {
	// Define configurations using a unique string identifier.
	AccountID param.Field[string] `path:"account_id" api:"required"`
}

type ConfigDeleteResponse = interface{}

type ConfigDeleteResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors" api:"required"`
	Messages []shared.ResponseInfo `json:"messages" api:"required"`
	Result   ConfigDeleteResponse  `json:"result" api:"required,nullable"`
	// Return the status of the API call success.
	Success ConfigDeleteResponseEnvelopeSuccess `json:"success" api:"required"`
	JSON    configDeleteResponseEnvelopeJSON    `json:"-"`
}

type ConfigDeleteResponseEnvelopeSuccess bool

type ConfigEditParams struct {
	// Define configurations using a unique string identifier.
	AccountID param.Field[string]                       `path:"account_id" api:"required"`
	Caching   param.Field[ConfigEditParamsCachingUnion] `json:"caching"`
	// mTLS configuration for the origin connection. Cannot be used with VPC Service
	// origins; TLS must be managed on the VPC Service.
	MTLS param.Field[ConfigEditParamsMTLS] `json:"mtls"`
	// The name of the Hyperdrive configuration. Used to identify the configuration in
	// the Cloudflare dashboard and API. An empty value leaves the name unchanged.
	Name param.Field[string] `json:"name"`
	// Connect to a database through a Workers VPC Service. TLS settings (mTLS,
	// sslmode) cannot be configured on the Hyperdrive when using a VPC Service origin;
	// TLS must be managed on the VPC Service itself.
	Origin param.Field[ConfigEditParamsOriginUnion] `json:"origin"`
	// The (soft) maximum number of connections the Hyperdrive is allowed to make to
	// the origin database.
	//
	// Maximum allowed: 20 for free tier accounts, 100 for paid tier accounts. If not
	// specified, defaults to 20 for free tier and 60 for paid tier. Certain
	// Cloudflare-managed origins may be permitted a higher limit. Contact Cloudflare
	// if you need a higher limit.
	OriginConnectionLimit param.Field[int64] `json:"origin_connection_limit"`
}

type ConfigEditParamsCaching struct {
	// Set to true to disable caching of SQL responses. Default is false.
	Disabled param.Field[bool] `json:"disabled"`
	// Specify the maximum duration (in seconds) items should persist in the cache.
	// Defaults to 60 seconds if not specified.
	MaxAge param.Field[int64] `json:"max_age"`
	// Specify the number of seconds the cache may serve a stale response. Defaults to
	// 15 seconds if not specified.
	StaleWhileRevalidate param.Field[int64] `json:"stale_while_revalidate"`
}

type ConfigEditParamsCachingHyperdriveHyperdriveCachingCommon struct {
	// Set to true to disable caching of SQL responses. Default is false.
	Disabled param.Field[bool] `json:"disabled"`
}

type ConfigEditParamsCachingHyperdriveHyperdriveCachingEnabled struct {
	// Set to true to disable caching of SQL responses. Default is false.
	Disabled param.Field[bool] `json:"disabled"`
	// Specify the maximum duration (in seconds) items should persist in the cache.
	// Defaults to 60 seconds if not specified.
	MaxAge param.Field[int64] `json:"max_age"`
	// Specify the number of seconds the cache may serve a stale response. Defaults to
	// 15 seconds if not specified.
	StaleWhileRevalidate param.Field[int64] `json:"stale_while_revalidate"`
}

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

type ConfigEditParamsMTLS struct {
	// Define CA certificate ID obtained after uploading CA cert.
	CACertificateID param.Field[string] `json:"ca_certificate_id"`
	// Define mTLS certificate ID obtained after uploading client cert.
	MTLSCertificateID param.Field[string] `json:"mtls_certificate_id"`
	// PostgreSQL accepts `require`, `verify-ca`, and `verify-full`. MySQL accepts
	// `REQUIRED`, `VERIFY_CA`, and `VERIFY_IDENTITY`. The verify modes require a CA
	// certificate; the require modes cannot be used with a CA certificate.
	Sslmode param.Field[string] `json:"sslmode"`
}

type ConfigEditParamsOrigin struct {
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID param.Field[string] `json:"access_client_id"`
	// Defines the Client Secret of the Access Token to use when connecting to the
	// origin database. The API never returns this write-only value.
	AccessClientSecret param.Field[string] `json:"access_client_secret"`
	// Set the name of your origin database.
	Database param.Field[string] `json:"database"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host param.Field[string] `json:"host"`
	// Set the password needed to access your origin database. The API never returns
	// this write-only value.
	Password param.Field[string] `json:"password"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port param.Field[int64] `json:"port"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme param.Field[ConfigEditParamsOriginScheme] `json:"scheme"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID param.Field[string] `json:"service_id"`
	// Set the user of your origin database.
	User param.Field[string] `json:"user"`
}

type ConfigEditParamsOriginHyperdriveHyperdriveDatabase struct {
	// Set the name of your origin database.
	Database param.Field[string] `json:"database"`
	// Set the password needed to access your origin database. The API never returns
	// this write-only value.
	Password param.Field[string] `json:"password"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme param.Field[ConfigEditParamsOriginHyperdriveHyperdriveDatabaseScheme] `json:"scheme"`
	// Set the user of your origin database.
	User param.Field[string] `json:"user"`
}

type ConfigEditParamsOriginHyperdriveHyperdriveDatabaseScheme string

type ConfigEditParamsOriginHyperdriveInternetOrigin struct {
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host param.Field[string] `json:"host" api:"required"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port param.Field[int64] `json:"port" api:"required"`
}

type ConfigEditParamsOriginHyperdriveOverAccessOrigin struct {
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID param.Field[string] `json:"access_client_id" api:"required"`
	// Defines the Client Secret of the Access Token to use when connecting to the
	// origin database. The API never returns this write-only value.
	AccessClientSecret param.Field[string] `json:"access_client_secret" api:"required"`
	// Defines the host (hostname or IP) of your origin database.
	Host param.Field[string] `json:"host" api:"required"`
}

type ConfigEditParamsOriginHyperdriveVPCServiceOrigin struct {
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID param.Field[string] `json:"service_id" api:"required"`
}

type ConfigEditParamsOriginScheme string

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

type ConfigEditResponse struct {
	// Define configurations using a unique string identifier.
	ID      string                    `json:"id" api:"required"`
	Caching ConfigEditResponseCaching `json:"caching" api:"required"`
	// The name of the Hyperdrive configuration. Used to identify the configuration in
	// the Cloudflare dashboard and API.
	Name string `json:"name" api:"required"`
	// Combines database connection fields with exactly one supported network location.
	Origin ConfigEditResponseOrigin `json:"origin" api:"required"`
	// Defines the creation time of the Hyperdrive configuration.
	CreatedOn time.Time `json:"created_on" format:"date-time"`
	// Selects a PlanetScale database and provisions credentials managed by Cloudflare
	// when creating a Hyperdrive configuration. The Cloudflare account must already be
	// linked to PlanetScale in the Hyperdrive dashboard. The selection is returned as
	// read-only metadata and cannot be changed with replace or update operations.
	Integration ConfigEditResponseIntegration `json:"integration"`
	// Defines the last modified time of the Hyperdrive configuration.
	ModifiedOn time.Time `json:"modified_on" format:"date-time"`
	// mTLS configuration for the origin connection. Cannot be used with VPC Service
	// origins; TLS must be managed on the VPC Service.
	MTLS ConfigEditResponseMTLS `json:"mtls"`
	// The (soft) maximum number of connections the Hyperdrive is allowed to make to
	// the origin database.
	//
	// Maximum allowed: 20 for free tier accounts, 100 for paid tier accounts. If not
	// specified, defaults to 20 for free tier and 60 for paid tier. Certain
	// Cloudflare-managed origins may be permitted a higher limit. Contact Cloudflare
	// if you need a higher limit.
	OriginConnectionLimit int64 `json:"origin_connection_limit"`
	// Defines the last time the Hyperdrive connection pool was explicitly restarted
	// via the restart endpoint. Omitted if the pool has never been explicitly
	// restarted.
	RestartedOn time.Time              `json:"restarted_on" api:"nullable" format:"date-time"`
	JSON        configEditResponseJSON `json:"-"`
}

type ConfigEditResponseCaching struct {
	// Defines whether caching is disabled.
	Disabled bool `json:"disabled" api:"required"`
	// Defines the maximum duration (in seconds) items persist in the cache.
	MaxAge int64 `json:"max_age"`
	// Defines the number of seconds the cache may serve a stale response.
	StaleWhileRevalidate int64                         `json:"stale_while_revalidate"`
	JSON                 configEditResponseCachingJSON `json:"-"`
}

type ConfigEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors" api:"required"`
	Messages []shared.ResponseInfo `json:"messages" api:"required"`
	Result   ConfigEditResponse    `json:"result" api:"required"`
	// Return the status of the API call success.
	Success ConfigEditResponseEnvelopeSuccess `json:"success" api:"required"`
	JSON    configEditResponseEnvelopeJSON    `json:"-"`
}

type ConfigEditResponseEnvelopeSuccess bool

type ConfigEditResponseIntegration struct {
	// The name of the PlanetScale database branch.
	DatabaseBranchName string `json:"database_branch_name" api:"required"`
	// The name of the PlanetScale database.
	DatabaseName string `json:"database_name" api:"required"`
	// The name of the PlanetScale organization.
	OrganizationName string `json:"organization_name" api:"required"`
	// The database integration provider used by this operation.
	Provider ConfigEditResponseIntegrationProvider `json:"provider" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigEditResponseIntegrationScheme `json:"scheme" api:"required"`
	// The database name to use when connecting. Defaults to `postgres` for PostgreSQL
	// and `mysql` for MySQL.
	CustomDatabaseName string                            `json:"custom_database_name"`
	JSON               configEditResponseIntegrationJSON `json:"-"`
}

type ConfigEditResponseIntegrationProvider string

type ConfigEditResponseIntegrationScheme string

type ConfigEditResponseMTLS struct {
	// Define CA certificate ID obtained after uploading CA cert.
	CACertificateID string `json:"ca_certificate_id"`
	// Define mTLS certificate ID obtained after uploading client cert.
	MTLSCertificateID string `json:"mtls_certificate_id"`
	// PostgreSQL accepts `require`, `verify-ca`, and `verify-full`. MySQL accepts
	// `REQUIRED`, `VERIFY_CA`, and `VERIFY_IDENTITY`. The verify modes require a CA
	// certificate; the require modes cannot be used with a CA certificate.
	Sslmode string                     `json:"sslmode"`
	JSON    configEditResponseMTLSJSON `json:"-"`
}

type ConfigEditResponseOrigin struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigEditResponseOriginScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string `json:"user" api:"required"`
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID string `json:"access_client_id"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host string `json:"host"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port int64 `json:"port"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID string                       `json:"service_id"`
	JSON      configEditResponseOriginJSON `json:"-"`
	// contains filtered or unexported fields
}

type ConfigEditResponseOriginAccessProtectedDatabaseBehindCloudflareTunnel struct {
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID string `json:"access_client_id" api:"required"`
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Defines the host (hostname or IP) of your origin database.
	Host string `json:"host" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigEditResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string                                                                    `json:"user" api:"required"`
	JSON configEditResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelJSON `json:"-"`
}

type ConfigEditResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelScheme string

type ConfigEditResponseOriginDatabaseReachableThroughAWorkersVPC struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigEditResponseOriginDatabaseReachableThroughAWorkersVPCScheme `json:"scheme" api:"required"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID string `json:"service_id" api:"required"`
	// Set the user of your origin database.
	User string                                                          `json:"user" api:"required"`
	JSON configEditResponseOriginDatabaseReachableThroughAWorkersVPCJSON `json:"-"`
}

type ConfigEditResponseOriginDatabaseReachableThroughAWorkersVPCScheme string

type ConfigEditResponseOriginPublicDatabase struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host string `json:"host" api:"required"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port int64 `json:"port" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigEditResponseOriginPublicDatabaseScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string                                     `json:"user" api:"required"`
	JSON configEditResponseOriginPublicDatabaseJSON `json:"-"`
}

type ConfigEditResponseOriginPublicDatabaseScheme string

type ConfigEditResponseOriginScheme string

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

type ConfigGetParams struct {
	// Define configurations using a unique string identifier.
	AccountID param.Field[string] `path:"account_id" api:"required"`
}

type ConfigGetResponse struct {
	// Define configurations using a unique string identifier.
	ID      string                   `json:"id" api:"required"`
	Caching ConfigGetResponseCaching `json:"caching" api:"required"`
	// The name of the Hyperdrive configuration. Used to identify the configuration in
	// the Cloudflare dashboard and API.
	Name string `json:"name" api:"required"`
	// Combines database connection fields with exactly one supported network location.
	Origin ConfigGetResponseOrigin `json:"origin" api:"required"`
	// Defines the creation time of the Hyperdrive configuration.
	CreatedOn time.Time `json:"created_on" format:"date-time"`
	// Selects a PlanetScale database and provisions credentials managed by Cloudflare
	// when creating a Hyperdrive configuration. The Cloudflare account must already be
	// linked to PlanetScale in the Hyperdrive dashboard. The selection is returned as
	// read-only metadata and cannot be changed with replace or update operations.
	Integration ConfigGetResponseIntegration `json:"integration"`
	// Defines the last modified time of the Hyperdrive configuration.
	ModifiedOn time.Time `json:"modified_on" format:"date-time"`
	// mTLS configuration for the origin connection. Cannot be used with VPC Service
	// origins; TLS must be managed on the VPC Service.
	MTLS ConfigGetResponseMTLS `json:"mtls"`
	// The (soft) maximum number of connections the Hyperdrive is allowed to make to
	// the origin database.
	//
	// Maximum allowed: 20 for free tier accounts, 100 for paid tier accounts. If not
	// specified, defaults to 20 for free tier and 60 for paid tier. Certain
	// Cloudflare-managed origins may be permitted a higher limit. Contact Cloudflare
	// if you need a higher limit.
	OriginConnectionLimit int64 `json:"origin_connection_limit"`
	// Defines the last time the Hyperdrive connection pool was explicitly restarted
	// via the restart endpoint. Omitted if the pool has never been explicitly
	// restarted.
	RestartedOn time.Time             `json:"restarted_on" api:"nullable" format:"date-time"`
	JSON        configGetResponseJSON `json:"-"`
}

type ConfigGetResponseCaching struct {
	// Defines whether caching is disabled.
	Disabled bool `json:"disabled" api:"required"`
	// Defines the maximum duration (in seconds) items persist in the cache.
	MaxAge int64 `json:"max_age"`
	// Defines the number of seconds the cache may serve a stale response.
	StaleWhileRevalidate int64                        `json:"stale_while_revalidate"`
	JSON                 configGetResponseCachingJSON `json:"-"`
}

type ConfigGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors" api:"required"`
	Messages []shared.ResponseInfo `json:"messages" api:"required"`
	Result   ConfigGetResponse     `json:"result" api:"required"`
	// Return the status of the API call success.
	Success ConfigGetResponseEnvelopeSuccess `json:"success" api:"required"`
	JSON    configGetResponseEnvelopeJSON    `json:"-"`
}

type ConfigGetResponseEnvelopeSuccess bool

type ConfigGetResponseIntegration struct {
	// The name of the PlanetScale database branch.
	DatabaseBranchName string `json:"database_branch_name" api:"required"`
	// The name of the PlanetScale database.
	DatabaseName string `json:"database_name" api:"required"`
	// The name of the PlanetScale organization.
	OrganizationName string `json:"organization_name" api:"required"`
	// The database integration provider used by this operation.
	Provider ConfigGetResponseIntegrationProvider `json:"provider" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigGetResponseIntegrationScheme `json:"scheme" api:"required"`
	// The database name to use when connecting. Defaults to `postgres` for PostgreSQL
	// and `mysql` for MySQL.
	CustomDatabaseName string                           `json:"custom_database_name"`
	JSON               configGetResponseIntegrationJSON `json:"-"`
}

type ConfigGetResponseIntegrationProvider string

type ConfigGetResponseIntegrationScheme string

type ConfigGetResponseMTLS struct {
	// Define CA certificate ID obtained after uploading CA cert.
	CACertificateID string `json:"ca_certificate_id"`
	// Define mTLS certificate ID obtained after uploading client cert.
	MTLSCertificateID string `json:"mtls_certificate_id"`
	// PostgreSQL accepts `require`, `verify-ca`, and `verify-full`. MySQL accepts
	// `REQUIRED`, `VERIFY_CA`, and `VERIFY_IDENTITY`. The verify modes require a CA
	// certificate; the require modes cannot be used with a CA certificate.
	Sslmode string                    `json:"sslmode"`
	JSON    configGetResponseMTLSJSON `json:"-"`
}

type ConfigGetResponseOrigin struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigGetResponseOriginScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string `json:"user" api:"required"`
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID string `json:"access_client_id"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host string `json:"host"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port int64 `json:"port"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID string                      `json:"service_id"`
	JSON      configGetResponseOriginJSON `json:"-"`
	// contains filtered or unexported fields
}

type ConfigGetResponseOriginAccessProtectedDatabaseBehindCloudflareTunnel struct {
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID string `json:"access_client_id" api:"required"`
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Defines the host (hostname or IP) of your origin database.
	Host string `json:"host" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigGetResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string                                                                   `json:"user" api:"required"`
	JSON configGetResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelJSON `json:"-"`
}

type ConfigGetResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelScheme string

type ConfigGetResponseOriginDatabaseReachableThroughAWorkersVPC struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigGetResponseOriginDatabaseReachableThroughAWorkersVPCScheme `json:"scheme" api:"required"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID string `json:"service_id" api:"required"`
	// Set the user of your origin database.
	User string                                                         `json:"user" api:"required"`
	JSON configGetResponseOriginDatabaseReachableThroughAWorkersVPCJSON `json:"-"`
}

type ConfigGetResponseOriginDatabaseReachableThroughAWorkersVPCScheme string

type ConfigGetResponseOriginPublicDatabase struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host string `json:"host" api:"required"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port int64 `json:"port" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigGetResponseOriginPublicDatabaseScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string                                    `json:"user" api:"required"`
	JSON configGetResponseOriginPublicDatabaseJSON `json:"-"`
}

type ConfigGetResponseOriginPublicDatabaseScheme string

type ConfigGetResponseOriginScheme string

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

type ConfigListParams struct {
	// Define configurations using a unique string identifier.
	AccountID param.Field[string] `path:"account_id" api:"required"`
	// Page number of paginated results.
	Page param.Field[int64] `query:"page"`
	// Maximum number of results per page.
	PerPage param.Field[int64] `query:"per_page"`
}

type ConfigListResponse struct {
	// Define configurations using a unique string identifier.
	ID      string                    `json:"id" api:"required"`
	Caching ConfigListResponseCaching `json:"caching" api:"required"`
	// The name of the Hyperdrive configuration. Used to identify the configuration in
	// the Cloudflare dashboard and API.
	Name string `json:"name" api:"required"`
	// Combines database connection fields with exactly one supported network location.
	Origin ConfigListResponseOrigin `json:"origin" api:"required"`
	// Defines the creation time of the Hyperdrive configuration.
	CreatedOn time.Time `json:"created_on" format:"date-time"`
	// Selects a PlanetScale database and provisions credentials managed by Cloudflare
	// when creating a Hyperdrive configuration. The Cloudflare account must already be
	// linked to PlanetScale in the Hyperdrive dashboard. The selection is returned as
	// read-only metadata and cannot be changed with replace or update operations.
	Integration ConfigListResponseIntegration `json:"integration"`
	// Defines the last modified time of the Hyperdrive configuration.
	ModifiedOn time.Time `json:"modified_on" format:"date-time"`
	// mTLS configuration for the origin connection. Cannot be used with VPC Service
	// origins; TLS must be managed on the VPC Service.
	MTLS ConfigListResponseMTLS `json:"mtls"`
	// The (soft) maximum number of connections the Hyperdrive is allowed to make to
	// the origin database.
	//
	// Maximum allowed: 20 for free tier accounts, 100 for paid tier accounts. If not
	// specified, defaults to 20 for free tier and 60 for paid tier. Certain
	// Cloudflare-managed origins may be permitted a higher limit. Contact Cloudflare
	// if you need a higher limit.
	OriginConnectionLimit int64 `json:"origin_connection_limit"`
	// Defines the last time the Hyperdrive connection pool was explicitly restarted
	// via the restart endpoint. Omitted if the pool has never been explicitly
	// restarted.
	RestartedOn time.Time              `json:"restarted_on" api:"nullable" format:"date-time"`
	JSON        configListResponseJSON `json:"-"`
}

type ConfigListResponseCaching struct {
	// Defines whether caching is disabled.
	Disabled bool `json:"disabled" api:"required"`
	// Defines the maximum duration (in seconds) items persist in the cache.
	MaxAge int64 `json:"max_age"`
	// Defines the number of seconds the cache may serve a stale response.
	StaleWhileRevalidate int64                         `json:"stale_while_revalidate"`
	JSON                 configListResponseCachingJSON `json:"-"`
}

type ConfigListResponseIntegration struct {
	// The name of the PlanetScale database branch.
	DatabaseBranchName string `json:"database_branch_name" api:"required"`
	// The name of the PlanetScale database.
	DatabaseName string `json:"database_name" api:"required"`
	// The name of the PlanetScale organization.
	OrganizationName string `json:"organization_name" api:"required"`
	// The database integration provider used by this operation.
	Provider ConfigListResponseIntegrationProvider `json:"provider" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigListResponseIntegrationScheme `json:"scheme" api:"required"`
	// The database name to use when connecting. Defaults to `postgres` for PostgreSQL
	// and `mysql` for MySQL.
	CustomDatabaseName string                            `json:"custom_database_name"`
	JSON               configListResponseIntegrationJSON `json:"-"`
}

type ConfigListResponseIntegrationProvider string

type ConfigListResponseIntegrationScheme string

type ConfigListResponseMTLS struct {
	// Define CA certificate ID obtained after uploading CA cert.
	CACertificateID string `json:"ca_certificate_id"`
	// Define mTLS certificate ID obtained after uploading client cert.
	MTLSCertificateID string `json:"mtls_certificate_id"`
	// PostgreSQL accepts `require`, `verify-ca`, and `verify-full`. MySQL accepts
	// `REQUIRED`, `VERIFY_CA`, and `VERIFY_IDENTITY`. The verify modes require a CA
	// certificate; the require modes cannot be used with a CA certificate.
	Sslmode string                     `json:"sslmode"`
	JSON    configListResponseMTLSJSON `json:"-"`
}

type ConfigListResponseOrigin struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigListResponseOriginScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string `json:"user" api:"required"`
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID string `json:"access_client_id"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host string `json:"host"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port int64 `json:"port"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID string                       `json:"service_id"`
	JSON      configListResponseOriginJSON `json:"-"`
	// contains filtered or unexported fields
}

type ConfigListResponseOriginAccessProtectedDatabaseBehindCloudflareTunnel struct {
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID string `json:"access_client_id" api:"required"`
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Defines the host (hostname or IP) of your origin database.
	Host string `json:"host" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigListResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string                                                                    `json:"user" api:"required"`
	JSON configListResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelJSON `json:"-"`
}

type ConfigListResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelScheme string

type ConfigListResponseOriginDatabaseReachableThroughAWorkersVPC struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigListResponseOriginDatabaseReachableThroughAWorkersVPCScheme `json:"scheme" api:"required"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID string `json:"service_id" api:"required"`
	// Set the user of your origin database.
	User string                                                          `json:"user" api:"required"`
	JSON configListResponseOriginDatabaseReachableThroughAWorkersVPCJSON `json:"-"`
}

type ConfigListResponseOriginDatabaseReachableThroughAWorkersVPCScheme string

type ConfigListResponseOriginPublicDatabase struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host string `json:"host" api:"required"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port int64 `json:"port" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigListResponseOriginPublicDatabaseScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string                                     `json:"user" api:"required"`
	JSON configListResponseOriginPublicDatabaseJSON `json:"-"`
}

type ConfigListResponseOriginPublicDatabaseScheme string

type ConfigListResponseOriginScheme string

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

type ConfigNewParams struct {
	// Define configurations using a unique string identifier.
	AccountID param.Field[string] `path:"account_id" api:"required"`
	// A request to create a Hyperdrive configuration using exactly one of
	// caller-supplied origin credentials or a managed integration.
	Body ConfigNewParamsBodyUnion `json:"body" api:"required"`
}

type ConfigNewParamsBody struct {
	// The name of the Hyperdrive configuration. Used to identify the configuration in
	// the Cloudflare dashboard and API.
	Name        param.Field[string]      `json:"name" api:"required"`
	Caching     param.Field[interface{}] `json:"caching"`
	Integration param.Field[interface{}] `json:"integration"`
	MTLS        param.Field[interface{}] `json:"mtls"`
	Origin      param.Field[interface{}] `json:"origin"`
	// The (soft) maximum number of connections the Hyperdrive is allowed to make to
	// the origin database.
	//
	// Maximum allowed: 20 for free tier accounts, 100 for paid tier accounts. If not
	// specified, defaults to 20 for free tier and 60 for paid tier. Certain
	// Cloudflare-managed origins may be permitted a higher limit. Contact Cloudflare
	// if you need a higher limit.
	OriginConnectionLimit param.Field[int64] `json:"origin_connection_limit"`
}

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegration struct {
	// Selects a PlanetScale database and provisions credentials managed by Cloudflare
	// when creating a Hyperdrive configuration. The Cloudflare account must already be
	// linked to PlanetScale in the Hyperdrive dashboard. The selection is returned as
	// read-only metadata and cannot be changed with replace or update operations.
	Integration param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationIntegration] `json:"integration" api:"required"`
	// The name of the Hyperdrive configuration. Used to identify the configuration in
	// the Cloudflare dashboard and API.
	Name    param.Field[string]                                                                         `json:"name" api:"required"`
	Caching param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationCachingUnion] `json:"caching"`
	// mTLS configuration for the origin connection. Cannot be used with VPC Service
	// origins; TLS must be managed on the VPC Service.
	MTLS   param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationMTLS] `json:"mtls"`
	Origin param.Field[interface{}]                                                            `json:"origin"`
	// The (soft) maximum number of connections the Hyperdrive is allowed to make to
	// the origin database.
	//
	// Maximum allowed: 20 for free tier accounts, 100 for paid tier accounts. If not
	// specified, defaults to 20 for free tier and 60 for paid tier. Certain
	// Cloudflare-managed origins may be permitted a higher limit. Contact Cloudflare
	// if you need a higher limit.
	OriginConnectionLimit param.Field[int64] `json:"origin_connection_limit"`
}

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationCaching struct {
	Disabled             param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationCachingDisabled] `json:"disabled"`
	MaxAge               param.Field[int64]                                                                             `json:"max_age"`
	StaleWhileRevalidate param.Field[int64]                                                                             `json:"stale_while_revalidate"`
}

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationCachingDisabled bool

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationCachingHyperdriveHyperdriveCachingCreateDisabled struct {
	Disabled             param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationCachingHyperdriveHyperdriveCachingCreateDisabledDisabled] `json:"disabled" api:"required"`
	MaxAge               param.Field[int64]                                                                                                                      `json:"max_age"`
	StaleWhileRevalidate param.Field[int64]                                                                                                                      `json:"stale_while_revalidate"`
}

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationCachingHyperdriveHyperdriveCachingCreateDisabledDisabled bool

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationCachingHyperdriveHyperdriveCachingCreateEnabled struct {
	Disabled param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationCachingHyperdriveHyperdriveCachingCreateEnabledDisabled] `json:"disabled"`
	// Specify the maximum duration (in seconds) items should persist in the cache.
	// Defaults to 60 seconds if not specified.
	MaxAge param.Field[int64] `json:"max_age"`
	// Specify the number of seconds the cache may serve a stale response. Defaults to
	// 15 seconds if not specified.
	StaleWhileRevalidate param.Field[int64] `json:"stale_while_revalidate"`
}

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationCachingHyperdriveHyperdriveCachingCreateEnabledDisabled bool

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

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationIntegration struct {
	// The name of the PlanetScale database branch.
	DatabaseBranchName param.Field[string] `json:"database_branch_name" api:"required"`
	// The name of the PlanetScale database.
	DatabaseName param.Field[string] `json:"database_name" api:"required"`
	// The name of the PlanetScale organization.
	OrganizationName param.Field[string] `json:"organization_name" api:"required"`
	// The database integration provider used by this operation.
	Provider param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationIntegrationProvider] `json:"provider" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationIntegrationScheme] `json:"scheme" api:"required"`
	// The database name to use when connecting. Defaults to `postgres` for PostgreSQL
	// and `mysql` for MySQL.
	CustomDatabaseName param.Field[string] `json:"custom_database_name"`
}

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationIntegrationProvider string

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationIntegrationScheme string

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithIntegrationMTLS struct {
	// Define CA certificate ID obtained after uploading CA cert.
	CACertificateID param.Field[string] `json:"ca_certificate_id"`
	// Define mTLS certificate ID obtained after uploading client cert.
	MTLSCertificateID param.Field[string] `json:"mtls_certificate_id"`
	// PostgreSQL accepts `require`, `verify-ca`, and `verify-full`. MySQL accepts
	// `REQUIRED`, `VERIFY_CA`, and `VERIFY_IDENTITY`. The verify modes require a CA
	// certificate; the require modes cannot be used with a CA certificate.
	Sslmode param.Field[string] `json:"sslmode"`
}

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOrigin struct {
	// The name of the Hyperdrive configuration. Used to identify the configuration in
	// the Cloudflare dashboard and API.
	Name param.Field[string] `json:"name" api:"required"`
	// Combines database connection fields with exactly one supported network location.
	Origin      param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginOriginUnion]  `json:"origin" api:"required"`
	Caching     param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginCachingUnion] `json:"caching"`
	Integration param.Field[interface{}]                                                               `json:"integration"`
	// mTLS configuration for the origin connection. Cannot be used with VPC Service
	// origins; TLS must be managed on the VPC Service.
	MTLS param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginMTLS] `json:"mtls"`
	// The (soft) maximum number of connections the Hyperdrive is allowed to make to
	// the origin database.
	//
	// Maximum allowed: 20 for free tier accounts, 100 for paid tier accounts. If not
	// specified, defaults to 20 for free tier and 60 for paid tier. Certain
	// Cloudflare-managed origins may be permitted a higher limit. Contact Cloudflare
	// if you need a higher limit.
	OriginConnectionLimit param.Field[int64] `json:"origin_connection_limit"`
}

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginCaching struct {
	Disabled             param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginCachingDisabled] `json:"disabled"`
	MaxAge               param.Field[int64]                                                                        `json:"max_age"`
	StaleWhileRevalidate param.Field[int64]                                                                        `json:"stale_while_revalidate"`
}

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginCachingDisabled bool

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginCachingHyperdriveHyperdriveCachingCreateDisabled struct {
	Disabled             param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginCachingHyperdriveHyperdriveCachingCreateDisabledDisabled] `json:"disabled" api:"required"`
	MaxAge               param.Field[int64]                                                                                                                 `json:"max_age"`
	StaleWhileRevalidate param.Field[int64]                                                                                                                 `json:"stale_while_revalidate"`
}

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginCachingHyperdriveHyperdriveCachingCreateDisabledDisabled bool

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginCachingHyperdriveHyperdriveCachingCreateEnabled struct {
	Disabled param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginCachingHyperdriveHyperdriveCachingCreateEnabledDisabled] `json:"disabled"`
	// Specify the maximum duration (in seconds) items should persist in the cache.
	// Defaults to 60 seconds if not specified.
	MaxAge param.Field[int64] `json:"max_age"`
	// Specify the number of seconds the cache may serve a stale response. Defaults to
	// 15 seconds if not specified.
	StaleWhileRevalidate param.Field[int64] `json:"stale_while_revalidate"`
}

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginCachingHyperdriveHyperdriveCachingCreateEnabledDisabled bool

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

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginMTLS struct {
	// Define CA certificate ID obtained after uploading CA cert.
	CACertificateID param.Field[string] `json:"ca_certificate_id"`
	// Define mTLS certificate ID obtained after uploading client cert.
	MTLSCertificateID param.Field[string] `json:"mtls_certificate_id"`
	// PostgreSQL accepts `require`, `verify-ca`, and `verify-full`. MySQL accepts
	// `REQUIRED`, `VERIFY_CA`, and `VERIFY_IDENTITY`. The verify modes require a CA
	// certificate; the require modes cannot be used with a CA certificate.
	Sslmode param.Field[string] `json:"sslmode"`
}

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginOrigin struct {
	// Set the name of your origin database.
	Database param.Field[string] `json:"database" api:"required"`
	// Set the password needed to access your origin database. The API never returns
	// this write-only value.
	Password param.Field[string] `json:"password" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginOriginScheme] `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User param.Field[string] `json:"user" api:"required"`
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID param.Field[string] `json:"access_client_id"`
	// Defines the Client Secret of the Access Token to use when connecting to the
	// origin database. The API never returns this write-only value.
	AccessClientSecret param.Field[string] `json:"access_client_secret"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host param.Field[string] `json:"host"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port param.Field[int64] `json:"port"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID param.Field[string] `json:"service_id"`
}

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginOriginAccessProtectedDatabaseBehindCloudflareTunnel struct {
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID param.Field[string] `json:"access_client_id" api:"required"`
	// Defines the Client Secret of the Access Token to use when connecting to the
	// origin database. The API never returns this write-only value.
	AccessClientSecret param.Field[string] `json:"access_client_secret" api:"required"`
	// Set the name of your origin database.
	Database param.Field[string] `json:"database" api:"required"`
	// Defines the host (hostname or IP) of your origin database.
	Host param.Field[string] `json:"host" api:"required"`
	// Set the password needed to access your origin database. The API never returns
	// this write-only value.
	Password param.Field[string] `json:"password" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginOriginAccessProtectedDatabaseBehindCloudflareTunnelScheme] `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User param.Field[string] `json:"user" api:"required"`
}

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginOriginAccessProtectedDatabaseBehindCloudflareTunnelScheme string

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginOriginDatabaseReachableThroughAWorkersVPC struct {
	// Set the name of your origin database.
	Database param.Field[string] `json:"database" api:"required"`
	// Set the password needed to access your origin database. The API never returns
	// this write-only value.
	Password param.Field[string] `json:"password" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginOriginDatabaseReachableThroughAWorkersVPCScheme] `json:"scheme" api:"required"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID param.Field[string] `json:"service_id" api:"required"`
	// Set the user of your origin database.
	User param.Field[string] `json:"user" api:"required"`
}

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginOriginDatabaseReachableThroughAWorkersVPCScheme string

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginOriginPublicDatabase struct {
	// Set the name of your origin database.
	Database param.Field[string] `json:"database" api:"required"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host param.Field[string] `json:"host" api:"required"`
	// Set the password needed to access your origin database. The API never returns
	// this write-only value.
	Password param.Field[string] `json:"password" api:"required"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port param.Field[int64] `json:"port" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme param.Field[ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginOriginPublicDatabaseScheme] `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User param.Field[string] `json:"user" api:"required"`
}

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginOriginPublicDatabaseScheme string

type ConfigNewParamsBodyHyperdriveHyperdriveConfigCreateWithOriginOriginScheme string

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

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

type ConfigNewResponse struct {
	// Define configurations using a unique string identifier.
	ID      string                   `json:"id" api:"required"`
	Caching ConfigNewResponseCaching `json:"caching" api:"required"`
	// The name of the Hyperdrive configuration. Used to identify the configuration in
	// the Cloudflare dashboard and API.
	Name string `json:"name" api:"required"`
	// Combines database connection fields with exactly one supported network location.
	Origin ConfigNewResponseOrigin `json:"origin" api:"required"`
	// Defines the creation time of the Hyperdrive configuration.
	CreatedOn time.Time `json:"created_on" format:"date-time"`
	// Selects a PlanetScale database and provisions credentials managed by Cloudflare
	// when creating a Hyperdrive configuration. The Cloudflare account must already be
	// linked to PlanetScale in the Hyperdrive dashboard. The selection is returned as
	// read-only metadata and cannot be changed with replace or update operations.
	Integration ConfigNewResponseIntegration `json:"integration"`
	// Defines the last modified time of the Hyperdrive configuration.
	ModifiedOn time.Time `json:"modified_on" format:"date-time"`
	// mTLS configuration for the origin connection. Cannot be used with VPC Service
	// origins; TLS must be managed on the VPC Service.
	MTLS ConfigNewResponseMTLS `json:"mtls"`
	// The (soft) maximum number of connections the Hyperdrive is allowed to make to
	// the origin database.
	//
	// Maximum allowed: 20 for free tier accounts, 100 for paid tier accounts. If not
	// specified, defaults to 20 for free tier and 60 for paid tier. Certain
	// Cloudflare-managed origins may be permitted a higher limit. Contact Cloudflare
	// if you need a higher limit.
	OriginConnectionLimit int64 `json:"origin_connection_limit"`
	// Defines the last time the Hyperdrive connection pool was explicitly restarted
	// via the restart endpoint. Omitted if the pool has never been explicitly
	// restarted.
	RestartedOn time.Time             `json:"restarted_on" api:"nullable" format:"date-time"`
	JSON        configNewResponseJSON `json:"-"`
}

type ConfigNewResponseCaching struct {
	// Defines whether caching is disabled.
	Disabled bool `json:"disabled" api:"required"`
	// Defines the maximum duration (in seconds) items persist in the cache.
	MaxAge int64 `json:"max_age"`
	// Defines the number of seconds the cache may serve a stale response.
	StaleWhileRevalidate int64                        `json:"stale_while_revalidate"`
	JSON                 configNewResponseCachingJSON `json:"-"`
}

type ConfigNewResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors" api:"required"`
	Messages []shared.ResponseInfo `json:"messages" api:"required"`
	Result   ConfigNewResponse     `json:"result" api:"required"`
	// Return the status of the API call success.
	Success ConfigNewResponseEnvelopeSuccess `json:"success" api:"required"`
	JSON    configNewResponseEnvelopeJSON    `json:"-"`
}

type ConfigNewResponseEnvelopeSuccess bool

type ConfigNewResponseIntegration struct {
	// The name of the PlanetScale database branch.
	DatabaseBranchName string `json:"database_branch_name" api:"required"`
	// The name of the PlanetScale database.
	DatabaseName string `json:"database_name" api:"required"`
	// The name of the PlanetScale organization.
	OrganizationName string `json:"organization_name" api:"required"`
	// The database integration provider used by this operation.
	Provider ConfigNewResponseIntegrationProvider `json:"provider" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigNewResponseIntegrationScheme `json:"scheme" api:"required"`
	// The database name to use when connecting. Defaults to `postgres` for PostgreSQL
	// and `mysql` for MySQL.
	CustomDatabaseName string                           `json:"custom_database_name"`
	JSON               configNewResponseIntegrationJSON `json:"-"`
}

type ConfigNewResponseIntegrationProvider string

type ConfigNewResponseIntegrationScheme string

type ConfigNewResponseMTLS struct {
	// Define CA certificate ID obtained after uploading CA cert.
	CACertificateID string `json:"ca_certificate_id"`
	// Define mTLS certificate ID obtained after uploading client cert.
	MTLSCertificateID string `json:"mtls_certificate_id"`
	// PostgreSQL accepts `require`, `verify-ca`, and `verify-full`. MySQL accepts
	// `REQUIRED`, `VERIFY_CA`, and `VERIFY_IDENTITY`. The verify modes require a CA
	// certificate; the require modes cannot be used with a CA certificate.
	Sslmode string                    `json:"sslmode"`
	JSON    configNewResponseMTLSJSON `json:"-"`
}

type ConfigNewResponseOrigin struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigNewResponseOriginScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string `json:"user" api:"required"`
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID string `json:"access_client_id"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host string `json:"host"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port int64 `json:"port"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID string                      `json:"service_id"`
	JSON      configNewResponseOriginJSON `json:"-"`
	// contains filtered or unexported fields
}

type ConfigNewResponseOriginAccessProtectedDatabaseBehindCloudflareTunnel struct {
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID string `json:"access_client_id" api:"required"`
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Defines the host (hostname or IP) of your origin database.
	Host string `json:"host" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigNewResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string                                                                   `json:"user" api:"required"`
	JSON configNewResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelJSON `json:"-"`
}

type ConfigNewResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelScheme string

type ConfigNewResponseOriginDatabaseReachableThroughAWorkersVPC struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigNewResponseOriginDatabaseReachableThroughAWorkersVPCScheme `json:"scheme" api:"required"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID string `json:"service_id" api:"required"`
	// Set the user of your origin database.
	User string                                                         `json:"user" api:"required"`
	JSON configNewResponseOriginDatabaseReachableThroughAWorkersVPCJSON `json:"-"`
}

type ConfigNewResponseOriginDatabaseReachableThroughAWorkersVPCScheme string

type ConfigNewResponseOriginPublicDatabase struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host string `json:"host" api:"required"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port int64 `json:"port" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigNewResponseOriginPublicDatabaseScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string                                    `json:"user" api:"required"`
	JSON configNewResponseOriginPublicDatabaseJSON `json:"-"`
}

type ConfigNewResponseOriginPublicDatabaseScheme string

type ConfigNewResponseOriginScheme string

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

type ConfigRestartParams struct {
	// Define configurations using a unique string identifier.
	AccountID param.Field[string] `path:"account_id" api:"required"`
}

type ConfigRestartResponse struct {
	// Define configurations using a unique string identifier.
	ID      string                       `json:"id" api:"required"`
	Caching ConfigRestartResponseCaching `json:"caching" api:"required"`
	// The name of the Hyperdrive configuration. Used to identify the configuration in
	// the Cloudflare dashboard and API.
	Name string `json:"name" api:"required"`
	// Combines database connection fields with exactly one supported network location.
	Origin ConfigRestartResponseOrigin `json:"origin" api:"required"`
	// Defines the creation time of the Hyperdrive configuration.
	CreatedOn time.Time `json:"created_on" format:"date-time"`
	// Selects a PlanetScale database and provisions credentials managed by Cloudflare
	// when creating a Hyperdrive configuration. The Cloudflare account must already be
	// linked to PlanetScale in the Hyperdrive dashboard. The selection is returned as
	// read-only metadata and cannot be changed with replace or update operations.
	Integration ConfigRestartResponseIntegration `json:"integration"`
	// Defines the last modified time of the Hyperdrive configuration.
	ModifiedOn time.Time `json:"modified_on" format:"date-time"`
	// mTLS configuration for the origin connection. Cannot be used with VPC Service
	// origins; TLS must be managed on the VPC Service.
	MTLS ConfigRestartResponseMTLS `json:"mtls"`
	// The (soft) maximum number of connections the Hyperdrive is allowed to make to
	// the origin database.
	//
	// Maximum allowed: 20 for free tier accounts, 100 for paid tier accounts. If not
	// specified, defaults to 20 for free tier and 60 for paid tier. Certain
	// Cloudflare-managed origins may be permitted a higher limit. Contact Cloudflare
	// if you need a higher limit.
	OriginConnectionLimit int64 `json:"origin_connection_limit"`
	// Defines the last time the Hyperdrive connection pool was explicitly restarted
	// via the restart endpoint. Omitted if the pool has never been explicitly
	// restarted.
	RestartedOn time.Time                 `json:"restarted_on" api:"nullable" format:"date-time"`
	JSON        configRestartResponseJSON `json:"-"`
}

type ConfigRestartResponseCaching struct {
	// Defines whether caching is disabled.
	Disabled bool `json:"disabled" api:"required"`
	// Defines the maximum duration (in seconds) items persist in the cache.
	MaxAge int64 `json:"max_age"`
	// Defines the number of seconds the cache may serve a stale response.
	StaleWhileRevalidate int64                            `json:"stale_while_revalidate"`
	JSON                 configRestartResponseCachingJSON `json:"-"`
}

type ConfigRestartResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors" api:"required"`
	Messages []shared.ResponseInfo `json:"messages" api:"required"`
	Result   ConfigRestartResponse `json:"result" api:"required"`
	// Return the status of the API call success.
	Success ConfigRestartResponseEnvelopeSuccess `json:"success" api:"required"`
	JSON    configRestartResponseEnvelopeJSON    `json:"-"`
}

type ConfigRestartResponseEnvelopeSuccess bool

type ConfigRestartResponseIntegration struct {
	// The name of the PlanetScale database branch.
	DatabaseBranchName string `json:"database_branch_name" api:"required"`
	// The name of the PlanetScale database.
	DatabaseName string `json:"database_name" api:"required"`
	// The name of the PlanetScale organization.
	OrganizationName string `json:"organization_name" api:"required"`
	// The database integration provider used by this operation.
	Provider ConfigRestartResponseIntegrationProvider `json:"provider" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigRestartResponseIntegrationScheme `json:"scheme" api:"required"`
	// The database name to use when connecting. Defaults to `postgres` for PostgreSQL
	// and `mysql` for MySQL.
	CustomDatabaseName string                               `json:"custom_database_name"`
	JSON               configRestartResponseIntegrationJSON `json:"-"`
}

type ConfigRestartResponseIntegrationProvider string

type ConfigRestartResponseIntegrationScheme string

type ConfigRestartResponseMTLS struct {
	// Define CA certificate ID obtained after uploading CA cert.
	CACertificateID string `json:"ca_certificate_id"`
	// Define mTLS certificate ID obtained after uploading client cert.
	MTLSCertificateID string `json:"mtls_certificate_id"`
	// PostgreSQL accepts `require`, `verify-ca`, and `verify-full`. MySQL accepts
	// `REQUIRED`, `VERIFY_CA`, and `VERIFY_IDENTITY`. The verify modes require a CA
	// certificate; the require modes cannot be used with a CA certificate.
	Sslmode string                        `json:"sslmode"`
	JSON    configRestartResponseMTLSJSON `json:"-"`
}

type ConfigRestartResponseOrigin struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigRestartResponseOriginScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string `json:"user" api:"required"`
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID string `json:"access_client_id"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host string `json:"host"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port int64 `json:"port"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID string                          `json:"service_id"`
	JSON      configRestartResponseOriginJSON `json:"-"`
	// contains filtered or unexported fields
}

type ConfigRestartResponseOriginAccessProtectedDatabaseBehindCloudflareTunnel struct {
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID string `json:"access_client_id" api:"required"`
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Defines the host (hostname or IP) of your origin database.
	Host string `json:"host" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigRestartResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string                                                                       `json:"user" api:"required"`
	JSON configRestartResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelJSON `json:"-"`
}

type ConfigRestartResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelScheme string

type ConfigRestartResponseOriginDatabaseReachableThroughAWorkersVPC struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigRestartResponseOriginDatabaseReachableThroughAWorkersVPCScheme `json:"scheme" api:"required"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID string `json:"service_id" api:"required"`
	// Set the user of your origin database.
	User string                                                             `json:"user" api:"required"`
	JSON configRestartResponseOriginDatabaseReachableThroughAWorkersVPCJSON `json:"-"`
}

type ConfigRestartResponseOriginDatabaseReachableThroughAWorkersVPCScheme string

type ConfigRestartResponseOriginPublicDatabase struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host string `json:"host" api:"required"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port int64 `json:"port" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigRestartResponseOriginPublicDatabaseScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string                                        `json:"user" api:"required"`
	JSON configRestartResponseOriginPublicDatabaseJSON `json:"-"`
}

type ConfigRestartResponseOriginPublicDatabaseScheme string

type ConfigRestartResponseOriginScheme string

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

type ConfigService struct {
	Options []option.RequestOption
}

type ConfigUpdateParams struct {
	// Define configurations using a unique string identifier.
	AccountID  param.Field[string] `path:"account_id" api:"required"`
	Hyperdrive HyperdriveParam     `json:"hyperdrive" api:"required"`
}

type ConfigUpdateResponse struct {
	// Define configurations using a unique string identifier.
	ID      string                      `json:"id" api:"required"`
	Caching ConfigUpdateResponseCaching `json:"caching" api:"required"`
	// The name of the Hyperdrive configuration. Used to identify the configuration in
	// the Cloudflare dashboard and API.
	Name string `json:"name" api:"required"`
	// Combines database connection fields with exactly one supported network location.
	Origin ConfigUpdateResponseOrigin `json:"origin" api:"required"`
	// Defines the creation time of the Hyperdrive configuration.
	CreatedOn time.Time `json:"created_on" format:"date-time"`
	// Selects a PlanetScale database and provisions credentials managed by Cloudflare
	// when creating a Hyperdrive configuration. The Cloudflare account must already be
	// linked to PlanetScale in the Hyperdrive dashboard. The selection is returned as
	// read-only metadata and cannot be changed with replace or update operations.
	Integration ConfigUpdateResponseIntegration `json:"integration"`
	// Defines the last modified time of the Hyperdrive configuration.
	ModifiedOn time.Time `json:"modified_on" format:"date-time"`
	// mTLS configuration for the origin connection. Cannot be used with VPC Service
	// origins; TLS must be managed on the VPC Service.
	MTLS ConfigUpdateResponseMTLS `json:"mtls"`
	// The (soft) maximum number of connections the Hyperdrive is allowed to make to
	// the origin database.
	//
	// Maximum allowed: 20 for free tier accounts, 100 for paid tier accounts. If not
	// specified, defaults to 20 for free tier and 60 for paid tier. Certain
	// Cloudflare-managed origins may be permitted a higher limit. Contact Cloudflare
	// if you need a higher limit.
	OriginConnectionLimit int64 `json:"origin_connection_limit"`
	// Defines the last time the Hyperdrive connection pool was explicitly restarted
	// via the restart endpoint. Omitted if the pool has never been explicitly
	// restarted.
	RestartedOn time.Time                `json:"restarted_on" api:"nullable" format:"date-time"`
	JSON        configUpdateResponseJSON `json:"-"`
}

type ConfigUpdateResponseCaching struct {
	// Defines whether caching is disabled.
	Disabled bool `json:"disabled" api:"required"`
	// Defines the maximum duration (in seconds) items persist in the cache.
	MaxAge int64 `json:"max_age"`
	// Defines the number of seconds the cache may serve a stale response.
	StaleWhileRevalidate int64                           `json:"stale_while_revalidate"`
	JSON                 configUpdateResponseCachingJSON `json:"-"`
}

type ConfigUpdateResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors" api:"required"`
	Messages []shared.ResponseInfo `json:"messages" api:"required"`
	Result   ConfigUpdateResponse  `json:"result" api:"required"`
	// Return the status of the API call success.
	Success ConfigUpdateResponseEnvelopeSuccess `json:"success" api:"required"`
	JSON    configUpdateResponseEnvelopeJSON    `json:"-"`
}

type ConfigUpdateResponseEnvelopeSuccess bool

type ConfigUpdateResponseIntegration struct {
	// The name of the PlanetScale database branch.
	DatabaseBranchName string `json:"database_branch_name" api:"required"`
	// The name of the PlanetScale database.
	DatabaseName string `json:"database_name" api:"required"`
	// The name of the PlanetScale organization.
	OrganizationName string `json:"organization_name" api:"required"`
	// The database integration provider used by this operation.
	Provider ConfigUpdateResponseIntegrationProvider `json:"provider" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigUpdateResponseIntegrationScheme `json:"scheme" api:"required"`
	// The database name to use when connecting. Defaults to `postgres` for PostgreSQL
	// and `mysql` for MySQL.
	CustomDatabaseName string                              `json:"custom_database_name"`
	JSON               configUpdateResponseIntegrationJSON `json:"-"`
}

type ConfigUpdateResponseIntegrationProvider string

type ConfigUpdateResponseIntegrationScheme string

type ConfigUpdateResponseMTLS struct {
	// Define CA certificate ID obtained after uploading CA cert.
	CACertificateID string `json:"ca_certificate_id"`
	// Define mTLS certificate ID obtained after uploading client cert.
	MTLSCertificateID string `json:"mtls_certificate_id"`
	// PostgreSQL accepts `require`, `verify-ca`, and `verify-full`. MySQL accepts
	// `REQUIRED`, `VERIFY_CA`, and `VERIFY_IDENTITY`. The verify modes require a CA
	// certificate; the require modes cannot be used with a CA certificate.
	Sslmode string                       `json:"sslmode"`
	JSON    configUpdateResponseMTLSJSON `json:"-"`
}

type ConfigUpdateResponseOrigin struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigUpdateResponseOriginScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string `json:"user" api:"required"`
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID string `json:"access_client_id"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host string `json:"host"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port int64 `json:"port"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID string                         `json:"service_id"`
	JSON      configUpdateResponseOriginJSON `json:"-"`
	// contains filtered or unexported fields
}

type ConfigUpdateResponseOriginAccessProtectedDatabaseBehindCloudflareTunnel struct {
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID string `json:"access_client_id" api:"required"`
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Defines the host (hostname or IP) of your origin database.
	Host string `json:"host" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigUpdateResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string                                                                      `json:"user" api:"required"`
	JSON configUpdateResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelJSON `json:"-"`
}

type ConfigUpdateResponseOriginAccessProtectedDatabaseBehindCloudflareTunnelScheme string

type ConfigUpdateResponseOriginDatabaseReachableThroughAWorkersVPC struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigUpdateResponseOriginDatabaseReachableThroughAWorkersVPCScheme `json:"scheme" api:"required"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID string `json:"service_id" api:"required"`
	// Set the user of your origin database.
	User string                                                            `json:"user" api:"required"`
	JSON configUpdateResponseOriginDatabaseReachableThroughAWorkersVPCJSON `json:"-"`
}

type ConfigUpdateResponseOriginDatabaseReachableThroughAWorkersVPCScheme string

type ConfigUpdateResponseOriginPublicDatabase struct {
	// Set the name of your origin database.
	Database string `json:"database" api:"required"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host string `json:"host" api:"required"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port int64 `json:"port" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme ConfigUpdateResponseOriginPublicDatabaseScheme `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User string                                       `json:"user" api:"required"`
	JSON configUpdateResponseOriginPublicDatabaseJSON `json:"-"`
}

type ConfigUpdateResponseOriginPublicDatabaseScheme string

type ConfigUpdateResponseOriginScheme string

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

type Error = apierror.Error

type ErrorData = shared.ErrorData

type ErrorDataSource = shared.ErrorDataSource

type HyperdriveCachingHyperdriveHyperdriveCachingCommonParam struct {
	// Set to true to disable caching of SQL responses. Default is false.
	Disabled param.Field[bool] `json:"disabled"`
}

type HyperdriveCachingHyperdriveHyperdriveCachingEnabledParam struct {
	// Set to true to disable caching of SQL responses. Default is false.
	Disabled param.Field[bool] `json:"disabled"`
	// Specify the maximum duration (in seconds) items should persist in the cache.
	// Defaults to 60 seconds if not specified.
	MaxAge param.Field[int64] `json:"max_age"`
	// Specify the number of seconds the cache may serve a stale response. Defaults to
	// 15 seconds if not specified.
	StaleWhileRevalidate param.Field[int64] `json:"stale_while_revalidate"`
}

type HyperdriveCachingParam struct {
	// Set to true to disable caching of SQL responses. Default is false.
	Disabled param.Field[bool] `json:"disabled"`
	// Specify the maximum duration (in seconds) items should persist in the cache.
	// Defaults to 60 seconds if not specified.
	MaxAge param.Field[int64] `json:"max_age"`
	// Specify the number of seconds the cache may serve a stale response. Defaults to
	// 15 seconds if not specified.
	StaleWhileRevalidate param.Field[int64] `json:"stale_while_revalidate"`
}

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

type HyperdriveMTLSParam struct {
	// Define CA certificate ID obtained after uploading CA cert.
	CACertificateID param.Field[string] `json:"ca_certificate_id"`
	// Define mTLS certificate ID obtained after uploading client cert.
	MTLSCertificateID param.Field[string] `json:"mtls_certificate_id"`
	// PostgreSQL accepts `require`, `verify-ca`, and `verify-full`. MySQL accepts
	// `REQUIRED`, `VERIFY_CA`, and `VERIFY_IDENTITY`. The verify modes require a CA
	// certificate; the require modes cannot be used with a CA certificate.
	Sslmode param.Field[string] `json:"sslmode"`
}

type HyperdriveOriginAccessProtectedDatabaseBehindCloudflareTunnelParam struct {
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID param.Field[string] `json:"access_client_id" api:"required"`
	// Defines the Client Secret of the Access Token to use when connecting to the
	// origin database. The API never returns this write-only value.
	AccessClientSecret param.Field[string] `json:"access_client_secret" api:"required"`
	// Set the name of your origin database.
	Database param.Field[string] `json:"database" api:"required"`
	// Defines the host (hostname or IP) of your origin database.
	Host param.Field[string] `json:"host" api:"required"`
	// Set the password needed to access your origin database. The API never returns
	// this write-only value.
	Password param.Field[string] `json:"password" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme param.Field[HyperdriveOriginAccessProtectedDatabaseBehindCloudflareTunnelScheme] `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User param.Field[string] `json:"user" api:"required"`
}

type HyperdriveOriginAccessProtectedDatabaseBehindCloudflareTunnelScheme string

type HyperdriveOriginDatabaseReachableThroughAWorkersVPCParam struct {
	// Set the name of your origin database.
	Database param.Field[string] `json:"database" api:"required"`
	// Set the password needed to access your origin database. The API never returns
	// this write-only value.
	Password param.Field[string] `json:"password" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme param.Field[HyperdriveOriginDatabaseReachableThroughAWorkersVPCScheme] `json:"scheme" api:"required"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID param.Field[string] `json:"service_id" api:"required"`
	// Set the user of your origin database.
	User param.Field[string] `json:"user" api:"required"`
}

type HyperdriveOriginDatabaseReachableThroughAWorkersVPCScheme string

type HyperdriveOriginParam struct {
	// Set the name of your origin database.
	Database param.Field[string] `json:"database" api:"required"`
	// Set the password needed to access your origin database. The API never returns
	// this write-only value.
	Password param.Field[string] `json:"password" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme param.Field[HyperdriveOriginScheme] `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User param.Field[string] `json:"user" api:"required"`
	// Defines the Client ID of the Access token to use when connecting to the origin
	// database.
	AccessClientID param.Field[string] `json:"access_client_id"`
	// Defines the Client Secret of the Access Token to use when connecting to the
	// origin database. The API never returns this write-only value.
	AccessClientSecret param.Field[string] `json:"access_client_secret"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host param.Field[string] `json:"host"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port param.Field[int64] `json:"port"`
	// The identifier of the Workers VPC Service to connect through. Hyperdrive will
	// egress through the specified VPC Service to reach the origin database.
	ServiceID param.Field[string] `json:"service_id"`
}

type HyperdriveOriginPublicDatabaseParam struct {
	// Set the name of your origin database.
	Database param.Field[string] `json:"database" api:"required"`
	// Defines the publicly reachable hostname or IP of your origin database. Private,
	// loopback, and link-local IP addresses are not allowed.
	Host param.Field[string] `json:"host" api:"required"`
	// Set the password needed to access your origin database. The API never returns
	// this write-only value.
	Password param.Field[string] `json:"password" api:"required"`
	// Defines the port of your origin database. Defaults to 5432 for PostgreSQL or
	// 3306 for MySQL if not specified.
	Port param.Field[int64] `json:"port" api:"required"`
	// Specifies the URL scheme used to connect to your origin database.
	Scheme param.Field[HyperdriveOriginPublicDatabaseScheme] `json:"scheme" api:"required"`
	// Set the user of your origin database.
	User param.Field[string] `json:"user" api:"required"`
}

type HyperdriveOriginPublicDatabaseScheme string

type HyperdriveOriginScheme string

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

type HyperdriveParam struct {
	// The name of the Hyperdrive configuration. Used to identify the configuration in
	// the Cloudflare dashboard and API.
	Name param.Field[string] `json:"name" api:"required"`
	// Combines database connection fields with exactly one supported network location.
	Origin  param.Field[HyperdriveOriginUnionParam]  `json:"origin" api:"required"`
	Caching param.Field[HyperdriveCachingUnionParam] `json:"caching"`
	// mTLS configuration for the origin connection. Cannot be used with VPC Service
	// origins; TLS must be managed on the VPC Service.
	MTLS param.Field[HyperdriveMTLSParam] `json:"mtls"`
	// The (soft) maximum number of connections the Hyperdrive is allowed to make to
	// the origin database.
	//
	// Maximum allowed: 20 for free tier accounts, 100 for paid tier accounts. If not
	// specified, defaults to 20 for free tier and 60 for paid tier. Certain
	// Cloudflare-managed origins may be permitted a higher limit. Contact Cloudflare
	// if you need a higher limit.
	OriginConnectionLimit param.Field[int64] `json:"origin_connection_limit"`
}

type HyperdriveService struct {
	Options []option.RequestOption
	Configs *ConfigService
}

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