(function () {
'use strict';
if (!(/^/(dev|multipage)//.test(window.location.pathname))) {
return;
}

var fragid = decodeURIComponent(window.location.hash.substr(1));

if (fragid && document.getElementById(fragid)) {
return;
}

var xhr = new XMLHttpRequest();
xhr.responseType = 'json';
xhr.open('GET', '/multipage/fragment-links.json');
xhr.onload = function() {
var fragmentLinks = xhr.response;

// Handle section-foo.html links from the old old multipage version,
// and broken foo.html from the new version. Only run this for 404s.
if ((!fragid || !(fragid in fragmentLinks)) && document.title === '404 Not Found') {
  var m = window.location.pathname.match(/\/(?:section-)?([\w\-]+)\.html/);
  if (m) {
    fragid = m[1];
  }
}paquete aws

importar (
"fmt"
)

// DualStackEndpointState es una constante para describir el comportamiento de resolución del punto final de doble pila.
tipo DualStackEndpointState uint

constante (
// DualStackEndpointStateUnset es el comportamiento del valor predeterminado para la resolución de puntos finales de doble pila.
DualStackEndpointStateUnset DualStackEndpointState = iota

// DualStackEndpointStateEnabled habilita la resolución de puntos finales de doble pila para puntos finales de servicio.
Estado de punto final de doble pila habilitado

// DualStackEndpointStateDisabled deshabilita la resolución de puntos finales de doble pila para los puntos finales.
Estado de punto final de DualStack deshabilitado

)

// GetUseDualStackEndpoint toma las EndpointResolverOptions de un servicio y devuelve el valor UseDualStackEndpoint.
// Devuelve un valor booleano falso si las opciones proporcionadas no tienen un método para recuperar DualStackEndpointState.
func GetUseDualStackEndpoint(opciones ...interfaz{}) (valor DualStackEndpointState, encontrado bool) {
tipo interfaz iface {
ObtenerUsoDualStackEndpoint() EstadoDualStackEndpoint
}
para _, opción := rango opciones {
si yo, ok := opcion.(iface); ok {
valor = i.GetUseDualStackEndpoint()
encontrado = verdadero
romper
}
}
valor de retorno, encontrado
}

// FIPSEndpointState es una constante para describir el comportamiento de resolución del punto final FIPS.
tipo FIPSEndpointState uint

constante (
// FIPSEndpointStateUnset es el comportamiento del valor predeterminado para la resolución del punto final FIPS.
FIPSEndpointStateUnset FIPSEndpointState = iota

// FIPSEndpointStateEnabled habilita la resolución de puntos finales FIPS para puntos finales de servicio.
Estado del punto final FIPS habilitado

// FIPSEndpointStateDisabled deshabilita la resolución de puntos finales FIPS para los puntos finales.
FIPSEndpointStateDeshabilitado

)

// GetUseFIPSEndpoint toma las EndpointResolverOptions de un servicio y devuelve el valor UseDualStackEndpoint.
// Devuelve un valor booleano falso si las opciones proporcionadas no tienen un método para recuperar DualStackEndpointState.
func GetUseFIPSEndpoint(opciones ...interfaz{}) (valor FIPSEndpointState, encontrado bool) {
tipo interfaz iface {
ObtenerUsoFIPSEndpoint() EstadoFIPSEndpoint
}
para _, opción := rango opciones {
si yo, ok := opcion.(iface); ok {
valor = i.GetUseFIPSEndpoint()
encontrado = verdadero
romper
}
}
valor de retorno, encontrado
}

// El punto final representa el punto final en el que un cliente de servicio debe realizar una operación de API
// llama a.
//
// El SDK resolverá automáticamente estos puntos finales por cliente API utilizando un
// solucionadores de puntos finales internos. Si desea proporcionar puntos finales personalizados
// Para resolver el comportamiento, puede implementar la interfaz EndpointResolver.
//
// Obsoleto: esta estructura se utilizó con el [EndpointResolver] global
// interfaz, que ha quedado obsoleta en favor de un punto final específico del servicio
// resolución. Consulte la documentación de desuso de esa interfaz para obtener más información.
tipo Punto final estructura {
// El punto final de la URL base que los clientes de API del SDK usarán para realizar llamadas API.
// El SDK agregará como sufijo la ruta URI y los elementos de consulta a este punto final.
Cadena URL

// Especifica si el nombre de host del punto final puede ser modificado por la API del SDK
// cliente.
//
// Si el nombre de host es mutable, los clientes de la API del SDK pueden modificar cualquier parte del mismo.
// el nombre de host según los requisitos de la API (por ejemplo, agregar o
// eliminar contenido en el nombre de host). Por ejemplo, el cliente de API de Amazon S3
// anteponiendo "bucketname" al nombre del host, o cambiando el
// nombre de servicio del componente de nombre de host de "s3." a "s3-accesspoint.dualstack."
// para el punto final de doble pila de un recurso de punto de acceso S3.
//
// Se debe tener cuidado al proporcionar un punto final personalizado para una API. Si el
// El nombre de host del punto final es mutable y el cliente no puede modificarlo
// correctamente, la llamada de operación probablemente fallará o tendrá valores indefinidos
// comportamiento.
//
// Si el nombre de host es inmutable, los clientes de la API del SDK no lo modificarán.
// nombre de host de la URL. Esto puede provocar que el cliente API no funcione
// correctamente si la API requiere valores de nombre de host específicos de la operación
// para ser utilizado por el cliente.
//
// Esta bandera no modifica el comportamiento del cliente API si este punto final
// se utilizará en lugar de Endpoint Discovery, o si el punto final será
// Se utiliza para realizar el descubrimiento de puntos finales. Ese comportamiento se configura a través de
// Opciones del cliente API.
Nombre de host bool inmutable

// La partición de AWS a la que pertenece el punto final.
Cadena de identificación de partición

// El nombre del servicio que se debe utilizar para firmar las solicitudes al
// punto final.
Cadena de nombre de firma

// La región que debe usarse para firmar la solicitud al punto final.
Cadena SigningRegion

// El método de firma que se debe utilizar para firmar las solicitudes al
// punto final.
Cadena de método de firma

// La fuente del punto final. De manera predeterminada, será EndpointSourceServiceMetadata.
// Al proporcionar un punto final personalizado, debe establecer la fuente como EndpointSourceCustom.
// Si no se proporciona la fuente al proporcionar un punto final personalizado, es posible que el SDK no
// Realizar correctamente las mutaciones requeridas del host. La fuente debe usarse junto con
// Propiedad HostnameImmutable según el requisito de uso.
Punto final de origen Fuente

}

// EndpointSource es el tipo de fuente del punto final.
//
// Obsoleto: la estructura global [Endpoint] está obsoleta.
tipo EndpointSource int

constante (
// EndpointSourceServiceMetadata indica que los metadatos del punto final modelado del servicio se utilizan como fuente del punto final.
Metadatos del servicio EndpointSource EndpointSource = iota

// EndpointSourceCustom indica que el punto final es un punto final personalizado. Esta fuente debe utilizarse cuando
// El usuario proporciona un punto final personalizado para que lo utilice el SDK.
Punto final Fuente personalizada

)

// EndpointNotFoundError es un error centinela para indicar que el
// La implementación de EndpointResolver no pudo resolver un punto final para el
// servicio y región dados. Los solucionadores deben usar esto para indicar que una API
// el cliente debe retroceder e intentar usar su solucionador interno predeterminado para
// resolver el punto final.
tipo EndpointNotFoundError estructura {
Err error
}

// Error es el mensaje de error.
func (e *EndpointNotFoundError) Error() cadena {
devolver fmt.Sprintf("punto final no encontrado, %v", e.Err)
}

// Unwrap devuelve el error subyacente.
func (e *EndpointNotFoundError) desenrollar() error {
devolver e.Err
}

// EndpointResolver es un solucionador de puntos finales que se puede utilizar para proporcionar o
// anula un punto final para el servicio y la región indicados. Los clientes de API
// intente usar EndpointResolver primero para resolver un punto final si
// disponible. Si EndpointResolver devuelve un error EndpointNotFoundError,
// Los clientes de API volverán a intentar resolver el punto final utilizando su
// resolver punto final interno predeterminado.
//
// Obsoleto: la interfaz de resolución de punto final global está obsoleta. La API
// para la resolución del punto final ahora es único para cada servicio y se configura a través de
// Campo EndpointResolverV2 en las opciones del cliente de servicio. Establecer un valor para
// EndpointResolver en aws.Config o las opciones del cliente de servicio lo impedirán
// de usar cualquier característica de servicio relacionada con el punto final lanzada después de la
// Introducción de EndpointResolverV2. También puede encontrar problemas con EndpointResolverV2 o
// comportamiento inesperado al utilizar la antigua interfaz global con servicios que
// utilice muchas personalizaciones relacionadas con los puntos finales, como S3.
tipo interfaz EndpointResolver {
ResolveEndpoint(servicio, cadena de región) (Punto final, error)
}

// EndpointResolverFunc envuelve una función para satisfacer la interfaz EndpointResolver.
//
// Obsoleto: la interfaz de resolución de punto final global está obsoleta. Consulte
// documentos de desuso en [EndpointResolver].
tipo EndpointResolverFunc func(servicio, región cadena) (Punto final, error)

// ResolveEndpoint llama a la función envuelta y devuelve los resultados.
func (e EndpointResolverFunc) ResolveEndpoint(servicio, región cadena) (Endpoint, error) {
devuelve e(servicio, región)
}

// EndpointResolverWithOptions es un solucionador de puntos finales que se puede utilizar para proporcionar o
// anula un punto final para el servicio, la región y las opciones de punto final del cliente del servicio. Los clientes de API
// intente usar EndpointResolverWithOptions primero para resolver un punto final si
// disponible. Si EndpointResolverWithOptions devuelve un error EndpointNotFoundError,
// Los clientes de API volverán a intentar resolver el punto final utilizando su
// resolver punto final interno predeterminado.
//
// Obsoleto: la interfaz de resolución de punto final global está obsoleta. Consulte
// documentos de desuso en [EndpointResolver].
tipo interfaz EndpointResolverWithOptions {
ResolveEndpoint(servicio, cadena de región, opciones...interfaz{}) (Punto final, error)
}

// EndpointResolverWithOptionsFunc envuelve una función para satisfacer la interfaz EndpointResolverWithOptions.
//
// Obsoleto: la interfaz de resolución de punto final global está obsoleta. Consulte
// documentos de desuso en [EndpointResolver].
tipo EndpointResolverWithOptionsFunc func(servicio, región cadena, opciones ...interfaz{}) (Punto final, error)

// ResolveEndpoint llama a la función envuelta y devuelve los resultados.
func (e EndpointResolverWithOptionsFunc) ResolveEndpoint(servicio, región cadena, opciones ...interfaz{}) (Endpoint, error) {
devuelve e(servicio, región, opciones...)
}

// GetDisableHTTPS toma EndpointResolverOptions de un servicio y devuelve el valor DisableHTTPS.
// Devuelve un valor booleano falso si las opciones proporcionadas no tienen un método para recuperar DisableHTTPS.
func GetDisableHTTPS(opciones ...interfaz{}) (valor bool, encontrado bool) {
tipo interfaz iface {
booleano GetDisableHTTPS()
}
para _, opción := rango opciones {
si yo, ok := opcion.(iface); ok {
valor = i.GetDisableHTTPS()
encontrado = verdadero
romper
}
}
valor de retorno, encontrado
}

// GetResolvedRegion toma EndpointResolverOptions de un servicio y devuelve el valor ResolvedRegion.
// Devuelve un valor booleano falso si las opciones proporcionadas no tienen un método para recuperar ResolvedRegion.
func GetResolvedRegion(opciones ...interfaz{}) (valor cadena, encontrado bool) {
tipo interfaz iface {
Cadena GetResolvedRegion()
}
para _, opción := rango opciones {
si yo, ok := opcion.(iface); ok {
valor = i.GetResolvedRegion()
encontrado = verdadero
romper
}
}
valor de retorno, encontrado
}db/setup.sqlaws.Config