diff --git a/crates/factor-outbound-pg/src/client.rs b/crates/factor-outbound-pg/src/client.rs
index e1d4029a5..196817456 100644
--- a/crates/factor-outbound-pg/src/client.rs
+++ b/crates/factor-outbound-pg/src/client.rs
@@ -2,8 +2,8 @@ use anyhow::{anyhow, Result};
 use native_tls::TlsConnector;
 use postgres_native_tls::MakeTlsConnector;
 use spin_world::async_trait;
-use spin_world::spin::postgres::rdbms_types::{
-    self as v2, Column, DbDataType, DbValue, ParameterValue, RowSet,
+use spin_world::spin::postgres::postgres::{
+    self as v3, Column, DbDataType, DbValue, ParameterValue, RowSet,
 };
 use tokio_postgres::types::Type;
 use tokio_postgres::{config::SslMode, types::ToSql, Row};
@@ -19,13 +19,13 @@ pub trait Client {
         &self,
         statement: String,
         params: Vec<ParameterValue>,
-    ) -> Result<u64, v2::Error>;
+    ) -> Result<u64, v3::Error>;
 
     async fn query(
         &self,
         statement: String,
         params: Vec<ParameterValue>,
-    ) -> Result<RowSet, v2::Error>;
+    ) -> Result<RowSet, v3::Error>;
 }
 
 #[async_trait]
@@ -55,12 +55,12 @@ impl Client for TokioClient {
         &self,
         statement: String,
         params: Vec<ParameterValue>,
-    ) -> Result<u64, v2::Error> {
+    ) -> Result<u64, v3::Error> {
         let params = params
             .iter()
             .map(to_sql_parameter)
             .collect::<Result<Vec<_>>>()
-            .map_err(|e| v2::Error::ValueConversionFailed(format!("{:?}", e)))?;
+            .map_err(|e| v3::Error::ValueConversionFailed(format!("{:?}", e)))?;
 
         let params_refs: Vec<&(dyn ToSql + Sync)> = params
             .iter()
@@ -69,19 +69,19 @@ impl Client for TokioClient {
 
         self.execute(&statement, params_refs.as_slice())
             .await
-            .map_err(|e| v2::Error::QueryFailed(format!("{:?}", e)))
+            .map_err(|e| v3::Error::QueryFailed(format!("{:?}", e)))
     }
 
     async fn query(
         &self,
         statement: String,
         params: Vec<ParameterValue>,
-    ) -> Result<RowSet, v2::Error> {
+    ) -> Result<RowSet, v3::Error> {
         let params = params
             .iter()
             .map(to_sql_parameter)
             .collect::<Result<Vec<_>>>()
-            .map_err(|e| v2::Error::BadParameter(format!("{:?}", e)))?;
+            .map_err(|e| v3::Error::BadParameter(format!("{:?}", e)))?;
 
         let params_refs: Vec<&(dyn ToSql + Sync)> = params
             .iter()
@@ -91,7 +91,7 @@ impl Client for TokioClient {
         let results = self
             .query(&statement, params_refs.as_slice())
             .await
-            .map_err(|e| v2::Error::QueryFailed(format!("{:?}", e)))?;
+            .map_err(|e| v3::Error::QueryFailed(format!("{:?}", e)))?;
 
         if results.is_empty() {
             return Ok(RowSet {
@@ -105,7 +105,7 @@ impl Client for TokioClient {
             .iter()
             .map(convert_row)
             .collect::<Result<Vec<_>, _>>()
-            .map_err(|e| v2::Error::QueryFailed(format!("{:?}", e)))?;
+            .map_err(|e| v3::Error::QueryFailed(format!("{:?}", e)))?;
 
         Ok(RowSet { columns, rows })
     }
diff --git a/crates/factor-outbound-pg/src/host.rs b/crates/factor-outbound-pg/src/host.rs
index ed3f92902..b5d8c0922 100644
--- a/crates/factor-outbound-pg/src/host.rs
+++ b/crates/factor-outbound-pg/src/host.rs
@@ -1,10 +1,10 @@
 use anyhow::Result;
 use spin_core::{async_trait, wasmtime::component::Resource};
-use spin_world::spin::postgres::{self as v3};
+use spin_world::spin::postgres::postgres::{self as v3};
 use spin_world::v1::postgres as v1;
 use spin_world::v1::rdbms_types as v1_types;
 use spin_world::v2::postgres::{self as v2};
-use spin_world::v2::rdbms_types as v2types;
+use spin_world::v2::rdbms_types as v2_types;
 use tracing::field::Empty;
 use tracing::instrument;
 use tracing::Level;
@@ -16,24 +16,24 @@ impl<C: Client> InstanceState<C> {
     async fn open_connection<Conn: 'static>(
         &mut self,
         address: &str,
-    ) -> Result<Resource<Conn>, v3::rdbms_types::Error> {
+    ) -> Result<Resource<Conn>, v3::Error> {
         self.connections
             .push(
                 C::build_client(address)
                     .await
-                    .map_err(|e| v3::rdbms_types::Error::ConnectionFailed(format!("{e:?}")))?,
+                    .map_err(|e| v3::Error::ConnectionFailed(format!("{e:?}")))?,
             )
-            .map_err(|_| v3::rdbms_types::Error::ConnectionFailed("too many connections".into()))
+            .map_err(|_| v3::Error::ConnectionFailed("too many connections".into()))
             .map(Resource::new_own)
     }
 
     async fn get_client<Conn: 'static>(
         &mut self,
         connection: Resource<Conn>,
-    ) -> Result<&C, v3::rdbms_types::Error> {
+    ) -> Result<&C, v3::Error> {
         self.connections
             .get(connection.rep())
-            .ok_or_else(|| v3::rdbms_types::Error::ConnectionFailed("no connection found".into()))
+            .ok_or_else(|| v3::Error::ConnectionFailed("no connection found".into()))
     }
 
     async fn is_address_allowed(&self, address: &str) -> Result<bool> {
@@ -65,10 +65,7 @@ impl<C: Client> InstanceState<C> {
     }
 }
 
-#[async_trait]
-impl<C: Send + Sync + Client> v3::postgres::Host for InstanceState<C> {}
-
-fn v2_params_to_v3(params: Vec<v2types::ParameterValue>) -> Vec<v3::rdbms_types::ParameterValue> {
+fn v2_params_to_v3(params: Vec<v2_types::ParameterValue>) -> Vec<v3::ParameterValue> {
     params.into_iter().map(|p| p.into()).collect()
 }
 
@@ -77,18 +74,15 @@ impl<C: Send + Sync + Client> spin_world::spin::postgres::postgres::HostConnecti
     for InstanceState<C>
 {
     #[instrument(name = "spin_outbound_pg.open", skip(self, address), err(level = Level::INFO), fields(otel.kind = "client", db.system = "postgresql", db.address = Empty, server.port = Empty, db.namespace = Empty))]
-    async fn open(
-        &mut self,
-        address: String,
-    ) -> Result<Resource<v3::postgres::Connection>, v3::rdbms_types::Error> {
+    async fn open(&mut self, address: String) -> Result<Resource<v3::Connection>, v3::Error> {
         spin_factor_outbound_networking::record_address_fields(&address);
 
         if !self
             .is_address_allowed(&address)
             .await
-            .map_err(|e| v3::rdbms_types::Error::Other(e.to_string()))?
+            .map_err(|e| v3::Error::Other(e.to_string()))?
         {
-            return Err(v3::rdbms_types::Error::ConnectionFailed(format!(
+            return Err(v3::Error::ConnectionFailed(format!(
                 "address {address} is not permitted"
             )));
         }
@@ -98,10 +92,10 @@ impl<C: Send + Sync + Client> spin_world::spin::postgres::postgres::HostConnecti
     #[instrument(name = "spin_outbound_pg.execute", skip(self, connection, params), err(level = Level::INFO), fields(otel.kind = "client", db.system = "postgresql", otel.name = statement))]
     async fn execute(
         &mut self,
-        connection: Resource<v3::postgres::Connection>,
+        connection: Resource<v3::Connection>,
         statement: String,
-        params: Vec<v3::rdbms_types::ParameterValue>,
-    ) -> Result<u64, v3::rdbms_types::Error> {
+        params: Vec<v3::ParameterValue>,
+    ) -> Result<u64, v3::Error> {
         Ok(self
             .get_client(connection)
             .await?
@@ -112,10 +106,10 @@ impl<C: Send + Sync + Client> spin_world::spin::postgres::postgres::HostConnecti
     #[instrument(name = "spin_outbound_pg.query", skip(self, connection, params), err(level = Level::INFO), fields(otel.kind = "client", db.system = "postgresql", otel.name = statement))]
     async fn query(
         &mut self,
-        connection: Resource<v3::postgres::Connection>,
+        connection: Resource<v3::Connection>,
         statement: String,
-        params: Vec<v3::rdbms_types::ParameterValue>,
-    ) -> Result<v3::rdbms_types::RowSet, v3::rdbms_types::Error> {
+        params: Vec<v3::ParameterValue>,
+    ) -> Result<v3::RowSet, v3::Error> {
         Ok(self
             .get_client(connection)
             .await?
@@ -123,20 +117,20 @@ impl<C: Send + Sync + Client> spin_world::spin::postgres::postgres::HostConnecti
             .await?)
     }
 
-    async fn drop(&mut self, connection: Resource<v3::postgres::Connection>) -> anyhow::Result<()> {
+    async fn drop(&mut self, connection: Resource<v3::Connection>) -> anyhow::Result<()> {
         self.connections.remove(connection.rep());
         Ok(())
     }
 }
 
-impl<C: Send> v2types::Host for InstanceState<C> {
+impl<C: Send> v2_types::Host for InstanceState<C> {
     fn convert_error(&mut self, error: v2::Error) -> Result<v2::Error> {
         Ok(error)
     }
 }
 
-impl<C: Send> v3::rdbms_types::Host for InstanceState<C> {
-    fn convert_error(&mut self, error: v3::rdbms_types::Error) -> Result<v3::rdbms_types::Error> {
+impl<C: Send + Sync + Client> v3::Host for InstanceState<C> {
+    fn convert_error(&mut self, error: v3::Error) -> Result<v3::Error> {
         Ok(error)
     }
 }
@@ -144,7 +138,7 @@ impl<C: Send> v3::rdbms_types::Host for InstanceState<C> {
 /// Delegate a function call to the v3::HostConnection implementation
 macro_rules! delegate {
     ($self:ident.$name:ident($address:expr, $($arg:expr),*)) => {{
-        if !$self.is_address_allowed(&$address).await.map_err(|e| v3::rdbms_types::Error::Other(e.to_string()))? {
+        if !$self.is_address_allowed(&$address).await.map_err(|e| v3::Error::Other(e.to_string()))? {
             return Err(v1::PgError::ConnectionFailed(format!(
                 "address {} is not permitted", $address
             )));
@@ -153,7 +147,7 @@ macro_rules! delegate {
             Ok(c) => c,
             Err(e) => return Err(e.into()),
         };
-        <Self as v3::postgres::HostConnection>::$name($self, connection, $($arg),*)
+        <Self as v3::HostConnection>::$name($self, connection, $($arg),*)
             .await
             .map_err(|e| e.into())
     }};
@@ -185,7 +179,7 @@ impl<C: Send + Sync + Client> v2::HostConnection for InstanceState<C> {
         &mut self,
         connection: Resource<v2::Connection>,
         statement: String,
-        params: Vec<v2types::ParameterValue>,
+        params: Vec<v2_types::ParameterValue>,
     ) -> Result<u64, v2::Error> {
         Ok(self
             .get_client(connection)
@@ -199,8 +193,8 @@ impl<C: Send + Sync + Client> v2::HostConnection for InstanceState<C> {
         &mut self,
         connection: Resource<v2::Connection>,
         statement: String,
-        params: Vec<v2types::ParameterValue>,
-    ) -> Result<v2types::RowSet, v2::Error> {
+        params: Vec<v2_types::ParameterValue>,
+    ) -> Result<v2_types::RowSet, v2::Error> {
         Ok(self
             .get_client(connection)
             .await?
diff --git a/crates/factor-outbound-pg/tests/factor_test.rs b/crates/factor-outbound-pg/tests/factor_test.rs
index 3d47c91a1..ae0ab2876 100644
--- a/crates/factor-outbound-pg/tests/factor_test.rs
+++ b/crates/factor-outbound-pg/tests/factor_test.rs
@@ -6,10 +6,10 @@ use spin_factor_variables::VariablesFactor;
 use spin_factors::{anyhow, RuntimeFactors};
 use spin_factors_test::{toml, TestEnvironment};
 use spin_world::async_trait;
+use spin_world::spin::postgres::postgres::Error as PgError;
 use spin_world::spin::postgres::postgres::HostConnection;
 use spin_world::spin::postgres::postgres::{self as v2};
-use spin_world::spin::postgres::rdbms_types::Error as PgError;
-use spin_world::spin::postgres::rdbms_types::{ParameterValue, RowSet};
+use spin_world::spin::postgres::postgres::{ParameterValue, RowSet};
 
 #[derive(RuntimeFactors)]
 struct TestFactors {
diff --git a/crates/world/src/conversions.rs b/crates/world/src/conversions.rs
index 2c64aeea5..46ff0e49f 100644
--- a/crates/world/src/conversions.rs
+++ b/crates/world/src/conversions.rs
@@ -12,8 +12,8 @@ mod rdbms_types {
         }
     }
 
-    impl From<spin::postgres::rdbms_types::Column> for v1::rdbms_types::Column {
-        fn from(value: spin::postgres::rdbms_types::Column) -> Self {
+    impl From<spin::postgres::postgres::Column> for v1::rdbms_types::Column {
+        fn from(value: spin::postgres::postgres::Column) -> Self {
             v1::rdbms_types::Column {
                 name: value.name,
                 data_type: value.data_type.into(),
@@ -21,8 +21,8 @@ mod rdbms_types {
         }
     }
 
-    impl From<spin::postgres::rdbms_types::Column> for v2::rdbms_types::Column {
-        fn from(value: spin::postgres::rdbms_types::Column) -> Self {
+    impl From<spin::postgres::postgres::Column> for v2::rdbms_types::Column {
+        fn from(value: spin::postgres::postgres::Column) -> Self {
             v2::rdbms_types::Column {
                 name: value.name,
                 data_type: value.data_type.into(),
@@ -52,46 +52,30 @@ mod rdbms_types {
         }
     }
 
-    impl From<spin::postgres::rdbms_types::DbValue> for v1::rdbms_types::DbValue {
-        fn from(value: spin::postgres::rdbms_types::DbValue) -> v1::rdbms_types::DbValue {
+    impl From<spin::postgres::postgres::DbValue> for v1::rdbms_types::DbValue {
+        fn from(value: spin::postgres::postgres::DbValue) -> v1::rdbms_types::DbValue {
             match value {
-                spin::postgres::rdbms_types::DbValue::Boolean(b) => {
+                spin::postgres::postgres::DbValue::Boolean(b) => {
                     v1::rdbms_types::DbValue::Boolean(b)
                 }
-                spin::postgres::rdbms_types::DbValue::Int8(i) => v1::rdbms_types::DbValue::Int8(i),
-                spin::postgres::rdbms_types::DbValue::Int16(i) => {
-                    v1::rdbms_types::DbValue::Int16(i)
-                }
-                spin::postgres::rdbms_types::DbValue::Int32(i) => {
-                    v1::rdbms_types::DbValue::Int32(i)
-                }
-                spin::postgres::rdbms_types::DbValue::Int64(i) => {
-                    v1::rdbms_types::DbValue::Int64(i)
-                }
-                spin::postgres::rdbms_types::DbValue::Uint8(j) => {
-                    v1::rdbms_types::DbValue::Uint8(j)
-                }
-                spin::postgres::rdbms_types::DbValue::Uint16(u) => {
-                    v1::rdbms_types::DbValue::Uint16(u)
-                }
-                spin::postgres::rdbms_types::DbValue::Uint32(u) => {
-                    v1::rdbms_types::DbValue::Uint32(u)
-                }
-                spin::postgres::rdbms_types::DbValue::Uint64(u) => {
-                    v1::rdbms_types::DbValue::Uint64(u)
-                }
-                spin::postgres::rdbms_types::DbValue::Floating32(r) => {
+                spin::postgres::postgres::DbValue::Int8(i) => v1::rdbms_types::DbValue::Int8(i),
+                spin::postgres::postgres::DbValue::Int16(i) => v1::rdbms_types::DbValue::Int16(i),
+                spin::postgres::postgres::DbValue::Int32(i) => v1::rdbms_types::DbValue::Int32(i),
+                spin::postgres::postgres::DbValue::Int64(i) => v1::rdbms_types::DbValue::Int64(i),
+                spin::postgres::postgres::DbValue::Uint8(j) => v1::rdbms_types::DbValue::Uint8(j),
+                spin::postgres::postgres::DbValue::Uint16(u) => v1::rdbms_types::DbValue::Uint16(u),
+                spin::postgres::postgres::DbValue::Uint32(u) => v1::rdbms_types::DbValue::Uint32(u),
+                spin::postgres::postgres::DbValue::Uint64(u) => v1::rdbms_types::DbValue::Uint64(u),
+                spin::postgres::postgres::DbValue::Floating32(r) => {
                     v1::rdbms_types::DbValue::Floating32(r)
                 }
-                spin::postgres::rdbms_types::DbValue::Floating64(r) => {
+                spin::postgres::postgres::DbValue::Floating64(r) => {
                     v1::rdbms_types::DbValue::Floating64(r)
                 }
-                spin::postgres::rdbms_types::DbValue::Str(s) => v1::rdbms_types::DbValue::Str(s),
-                spin::postgres::rdbms_types::DbValue::Binary(b) => {
-                    v1::rdbms_types::DbValue::Binary(b)
-                }
-                spin::postgres::rdbms_types::DbValue::DbNull => v1::rdbms_types::DbValue::DbNull,
-                spin::postgres::rdbms_types::DbValue::Unsupported => {
+                spin::postgres::postgres::DbValue::Str(s) => v1::rdbms_types::DbValue::Str(s),
+                spin::postgres::postgres::DbValue::Binary(b) => v1::rdbms_types::DbValue::Binary(b),
+                spin::postgres::postgres::DbValue::DbNull => v1::rdbms_types::DbValue::DbNull,
+                spin::postgres::postgres::DbValue::Unsupported => {
                     v1::rdbms_types::DbValue::Unsupported
                 }
                 _ => v1::rdbms_types::DbValue::Unsupported,
@@ -99,46 +83,30 @@ mod rdbms_types {
         }
     }
 
-    impl From<spin::postgres::rdbms_types::DbValue> for v2::rdbms_types::DbValue {
-        fn from(value: spin::postgres::rdbms_types::DbValue) -> v2::rdbms_types::DbValue {
+    impl From<spin::postgres::postgres::DbValue> for v2::rdbms_types::DbValue {
+        fn from(value: spin::postgres::postgres::DbValue) -> v2::rdbms_types::DbValue {
             match value {
-                spin::postgres::rdbms_types::DbValue::Boolean(b) => {
+                spin::postgres::postgres::DbValue::Boolean(b) => {
                     v2::rdbms_types::DbValue::Boolean(b)
                 }
-                spin::postgres::rdbms_types::DbValue::Int8(i) => v2::rdbms_types::DbValue::Int8(i),
-                spin::postgres::rdbms_types::DbValue::Int16(i) => {
-                    v2::rdbms_types::DbValue::Int16(i)
-                }
-                spin::postgres::rdbms_types::DbValue::Int32(i) => {
-                    v2::rdbms_types::DbValue::Int32(i)
-                }
-                spin::postgres::rdbms_types::DbValue::Int64(i) => {
-                    v2::rdbms_types::DbValue::Int64(i)
-                }
-                spin::postgres::rdbms_types::DbValue::Uint8(j) => {
-                    v2::rdbms_types::DbValue::Uint8(j)
-                }
-                spin::postgres::rdbms_types::DbValue::Uint16(u) => {
-                    v2::rdbms_types::DbValue::Uint16(u)
-                }
-                spin::postgres::rdbms_types::DbValue::Uint32(u) => {
-                    v2::rdbms_types::DbValue::Uint32(u)
-                }
-                spin::postgres::rdbms_types::DbValue::Uint64(u) => {
-                    v2::rdbms_types::DbValue::Uint64(u)
-                }
-                spin::postgres::rdbms_types::DbValue::Floating32(r) => {
+                spin::postgres::postgres::DbValue::Int8(i) => v2::rdbms_types::DbValue::Int8(i),
+                spin::postgres::postgres::DbValue::Int16(i) => v2::rdbms_types::DbValue::Int16(i),
+                spin::postgres::postgres::DbValue::Int32(i) => v2::rdbms_types::DbValue::Int32(i),
+                spin::postgres::postgres::DbValue::Int64(i) => v2::rdbms_types::DbValue::Int64(i),
+                spin::postgres::postgres::DbValue::Uint8(j) => v2::rdbms_types::DbValue::Uint8(j),
+                spin::postgres::postgres::DbValue::Uint16(u) => v2::rdbms_types::DbValue::Uint16(u),
+                spin::postgres::postgres::DbValue::Uint32(u) => v2::rdbms_types::DbValue::Uint32(u),
+                spin::postgres::postgres::DbValue::Uint64(u) => v2::rdbms_types::DbValue::Uint64(u),
+                spin::postgres::postgres::DbValue::Floating32(r) => {
                     v2::rdbms_types::DbValue::Floating32(r)
                 }
-                spin::postgres::rdbms_types::DbValue::Floating64(r) => {
+                spin::postgres::postgres::DbValue::Floating64(r) => {
                     v2::rdbms_types::DbValue::Floating64(r)
                 }
-                spin::postgres::rdbms_types::DbValue::Str(s) => v2::rdbms_types::DbValue::Str(s),
-                spin::postgres::rdbms_types::DbValue::Binary(b) => {
-                    v2::rdbms_types::DbValue::Binary(b)
-                }
-                spin::postgres::rdbms_types::DbValue::DbNull => v2::rdbms_types::DbValue::DbNull,
-                spin::postgres::rdbms_types::DbValue::Unsupported => {
+                spin::postgres::postgres::DbValue::Str(s) => v2::rdbms_types::DbValue::Str(s),
+                spin::postgres::postgres::DbValue::Binary(b) => v2::rdbms_types::DbValue::Binary(b),
+                spin::postgres::postgres::DbValue::DbNull => v2::rdbms_types::DbValue::DbNull,
+                spin::postgres::postgres::DbValue::Unsupported => {
                     v2::rdbms_types::DbValue::Unsupported
                 }
                 _ => v2::rdbms_types::DbValue::Unsupported,
@@ -146,93 +114,57 @@ mod rdbms_types {
         }
     }
 
-    impl From<spin::postgres::rdbms_types::DbDataType> for v1::rdbms_types::DbDataType {
-        fn from(value: spin::postgres::rdbms_types::DbDataType) -> v1::rdbms_types::DbDataType {
+    impl From<spin::postgres::postgres::DbDataType> for v1::rdbms_types::DbDataType {
+        fn from(value: spin::postgres::postgres::DbDataType) -> v1::rdbms_types::DbDataType {
             match value {
-                spin::postgres::rdbms_types::DbDataType::Boolean => {
+                spin::postgres::postgres::DbDataType::Boolean => {
                     v1::rdbms_types::DbDataType::Boolean
                 }
-                spin::postgres::rdbms_types::DbDataType::Int8 => v1::rdbms_types::DbDataType::Int8,
-                spin::postgres::rdbms_types::DbDataType::Int16 => {
-                    v1::rdbms_types::DbDataType::Int16
-                }
-                spin::postgres::rdbms_types::DbDataType::Int32 => {
-                    v1::rdbms_types::DbDataType::Int32
-                }
-                spin::postgres::rdbms_types::DbDataType::Int64 => {
-                    v1::rdbms_types::DbDataType::Int64
-                }
-                spin::postgres::rdbms_types::DbDataType::Uint8 => {
-                    v1::rdbms_types::DbDataType::Uint8
-                }
-                spin::postgres::rdbms_types::DbDataType::Uint16 => {
-                    v1::rdbms_types::DbDataType::Uint16
-                }
-                spin::postgres::rdbms_types::DbDataType::Uint32 => {
-                    v1::rdbms_types::DbDataType::Uint32
-                }
-                spin::postgres::rdbms_types::DbDataType::Uint64 => {
-                    v1::rdbms_types::DbDataType::Uint64
-                }
-                spin::postgres::rdbms_types::DbDataType::Floating32 => {
+                spin::postgres::postgres::DbDataType::Int8 => v1::rdbms_types::DbDataType::Int8,
+                spin::postgres::postgres::DbDataType::Int16 => v1::rdbms_types::DbDataType::Int16,
+                spin::postgres::postgres::DbDataType::Int32 => v1::rdbms_types::DbDataType::Int32,
+                spin::postgres::postgres::DbDataType::Int64 => v1::rdbms_types::DbDataType::Int64,
+                spin::postgres::postgres::DbDataType::Uint8 => v1::rdbms_types::DbDataType::Uint8,
+                spin::postgres::postgres::DbDataType::Uint16 => v1::rdbms_types::DbDataType::Uint16,
+                spin::postgres::postgres::DbDataType::Uint32 => v1::rdbms_types::DbDataType::Uint32,
+                spin::postgres::postgres::DbDataType::Uint64 => v1::rdbms_types::DbDataType::Uint64,
+                spin::postgres::postgres::DbDataType::Floating32 => {
                     v1::rdbms_types::DbDataType::Floating32
                 }
-                spin::postgres::rdbms_types::DbDataType::Floating64 => {
+                spin::postgres::postgres::DbDataType::Floating64 => {
                     v1::rdbms_types::DbDataType::Floating64
                 }
-                spin::postgres::rdbms_types::DbDataType::Str => v1::rdbms_types::DbDataType::Str,
-                spin::postgres::rdbms_types::DbDataType::Binary => {
-                    v1::rdbms_types::DbDataType::Binary
-                }
-                spin::postgres::rdbms_types::DbDataType::Other => {
-                    v1::rdbms_types::DbDataType::Other
-                }
+                spin::postgres::postgres::DbDataType::Str => v1::rdbms_types::DbDataType::Str,
+                spin::postgres::postgres::DbDataType::Binary => v1::rdbms_types::DbDataType::Binary,
+                spin::postgres::postgres::DbDataType::Other => v1::rdbms_types::DbDataType::Other,
                 _ => v1::rdbms_types::DbDataType::Other,
             }
         }
     }
 
-    impl From<spin::postgres::rdbms_types::DbDataType> for v2::rdbms_types::DbDataType {
-        fn from(value: spin::postgres::rdbms_types::DbDataType) -> v2::rdbms_types::DbDataType {
+    impl From<spin::postgres::postgres::DbDataType> for v2::rdbms_types::DbDataType {
+        fn from(value: spin::postgres::postgres::DbDataType) -> v2::rdbms_types::DbDataType {
             match value {
-                spin::postgres::rdbms_types::DbDataType::Boolean => {
+                spin::postgres::postgres::DbDataType::Boolean => {
                     v2::rdbms_types::DbDataType::Boolean
                 }
-                spin::postgres::rdbms_types::DbDataType::Int8 => v2::rdbms_types::DbDataType::Int8,
-                spin::postgres::rdbms_types::DbDataType::Int16 => {
-                    v2::rdbms_types::DbDataType::Int16
-                }
-                spin::postgres::rdbms_types::DbDataType::Int32 => {
-                    v2::rdbms_types::DbDataType::Int32
-                }
-                spin::postgres::rdbms_types::DbDataType::Int64 => {
-                    v2::rdbms_types::DbDataType::Int64
-                }
-                spin::postgres::rdbms_types::DbDataType::Uint8 => {
-                    v2::rdbms_types::DbDataType::Uint8
-                }
-                spin::postgres::rdbms_types::DbDataType::Uint16 => {
-                    v2::rdbms_types::DbDataType::Uint16
-                }
-                spin::postgres::rdbms_types::DbDataType::Uint32 => {
-                    v2::rdbms_types::DbDataType::Uint32
-                }
-                spin::postgres::rdbms_types::DbDataType::Uint64 => {
-                    v2::rdbms_types::DbDataType::Uint64
-                }
-                spin::postgres::rdbms_types::DbDataType::Floating32 => {
+                spin::postgres::postgres::DbDataType::Int8 => v2::rdbms_types::DbDataType::Int8,
+                spin::postgres::postgres::DbDataType::Int16 => v2::rdbms_types::DbDataType::Int16,
+                spin::postgres::postgres::DbDataType::Int32 => v2::rdbms_types::DbDataType::Int32,
+                spin::postgres::postgres::DbDataType::Int64 => v2::rdbms_types::DbDataType::Int64,
+                spin::postgres::postgres::DbDataType::Uint8 => v2::rdbms_types::DbDataType::Uint8,
+                spin::postgres::postgres::DbDataType::Uint16 => v2::rdbms_types::DbDataType::Uint16,
+                spin::postgres::postgres::DbDataType::Uint32 => v2::rdbms_types::DbDataType::Uint32,
+                spin::postgres::postgres::DbDataType::Uint64 => v2::rdbms_types::DbDataType::Uint64,
+                spin::postgres::postgres::DbDataType::Floating32 => {
                     v2::rdbms_types::DbDataType::Floating32
                 }
-                spin::postgres::rdbms_types::DbDataType::Floating64 => {
+                spin::postgres::postgres::DbDataType::Floating64 => {
                     v2::rdbms_types::DbDataType::Floating64
                 }
-                spin::postgres::rdbms_types::DbDataType::Str => v2::rdbms_types::DbDataType::Str,
-                spin::postgres::rdbms_types::DbDataType::Binary => {
-                    v2::rdbms_types::DbDataType::Binary
-                }
-                spin::postgres::rdbms_types::DbDataType::Other => {
-                    v2::rdbms_types::DbDataType::Other
-                }
+                spin::postgres::postgres::DbDataType::Str => v2::rdbms_types::DbDataType::Str,
+                spin::postgres::postgres::DbDataType::Binary => v2::rdbms_types::DbDataType::Binary,
+                spin::postgres::postgres::DbDataType::Other => v2::rdbms_types::DbDataType::Other,
                 _ => v2::rdbms_types::DbDataType::Other,
             }
         }
@@ -304,103 +236,103 @@ mod rdbms_types {
         }
     }
 
-    impl From<v1::rdbms_types::ParameterValue> for spin::postgres::rdbms_types::ParameterValue {
+    impl From<v1::rdbms_types::ParameterValue> for spin::postgres::postgres::ParameterValue {
         fn from(
             value: v1::rdbms_types::ParameterValue,
-        ) -> spin::postgres::rdbms_types::ParameterValue {
+        ) -> spin::postgres::postgres::ParameterValue {
             match value {
                 v1::rdbms_types::ParameterValue::Boolean(b) => {
-                    spin::postgres::rdbms_types::ParameterValue::Boolean(b)
+                    spin::postgres::postgres::ParameterValue::Boolean(b)
                 }
                 v1::rdbms_types::ParameterValue::Int8(i) => {
-                    spin::postgres::rdbms_types::ParameterValue::Int8(i)
+                    spin::postgres::postgres::ParameterValue::Int8(i)
                 }
                 v1::rdbms_types::ParameterValue::Int16(i) => {
-                    spin::postgres::rdbms_types::ParameterValue::Int16(i)
+                    spin::postgres::postgres::ParameterValue::Int16(i)
                 }
                 v1::rdbms_types::ParameterValue::Int32(i) => {
-                    spin::postgres::rdbms_types::ParameterValue::Int32(i)
+                    spin::postgres::postgres::ParameterValue::Int32(i)
                 }
                 v1::rdbms_types::ParameterValue::Int64(i) => {
-                    spin::postgres::rdbms_types::ParameterValue::Int64(i)
+                    spin::postgres::postgres::ParameterValue::Int64(i)
                 }
                 v1::rdbms_types::ParameterValue::Uint8(u) => {
-                    spin::postgres::rdbms_types::ParameterValue::Uint8(u)
+                    spin::postgres::postgres::ParameterValue::Uint8(u)
                 }
                 v1::rdbms_types::ParameterValue::Uint16(u) => {
-                    spin::postgres::rdbms_types::ParameterValue::Uint16(u)
+                    spin::postgres::postgres::ParameterValue::Uint16(u)
                 }
                 v1::rdbms_types::ParameterValue::Uint32(u) => {
-                    spin::postgres::rdbms_types::ParameterValue::Uint32(u)
+                    spin::postgres::postgres::ParameterValue::Uint32(u)
                 }
                 v1::rdbms_types::ParameterValue::Uint64(u) => {
-                    spin::postgres::rdbms_types::ParameterValue::Uint64(u)
+                    spin::postgres::postgres::ParameterValue::Uint64(u)
                 }
                 v1::rdbms_types::ParameterValue::Floating32(r) => {
-                    spin::postgres::rdbms_types::ParameterValue::Floating32(r)
+                    spin::postgres::postgres::ParameterValue::Floating32(r)
                 }
                 v1::rdbms_types::ParameterValue::Floating64(r) => {
-                    spin::postgres::rdbms_types::ParameterValue::Floating64(r)
+                    spin::postgres::postgres::ParameterValue::Floating64(r)
                 }
                 v1::rdbms_types::ParameterValue::Str(s) => {
-                    spin::postgres::rdbms_types::ParameterValue::Str(s)
+                    spin::postgres::postgres::ParameterValue::Str(s)
                 }
                 v1::rdbms_types::ParameterValue::Binary(b) => {
-                    spin::postgres::rdbms_types::ParameterValue::Binary(b)
+                    spin::postgres::postgres::ParameterValue::Binary(b)
                 }
                 v1::rdbms_types::ParameterValue::DbNull => {
-                    spin::postgres::rdbms_types::ParameterValue::DbNull
+                    spin::postgres::postgres::ParameterValue::DbNull
                 }
             }
         }
     }
 
-    impl From<v2::rdbms_types::ParameterValue> for spin::postgres::rdbms_types::ParameterValue {
+    impl From<v2::rdbms_types::ParameterValue> for spin::postgres::postgres::ParameterValue {
         fn from(
             value: v2::rdbms_types::ParameterValue,
-        ) -> spin::postgres::rdbms_types::ParameterValue {
+        ) -> spin::postgres::postgres::ParameterValue {
             match value {
                 v2::rdbms_types::ParameterValue::Boolean(b) => {
-                    spin::postgres::rdbms_types::ParameterValue::Boolean(b)
+                    spin::postgres::postgres::ParameterValue::Boolean(b)
                 }
                 v2::rdbms_types::ParameterValue::Int8(i) => {
-                    spin::postgres::rdbms_types::ParameterValue::Int8(i)
+                    spin::postgres::postgres::ParameterValue::Int8(i)
                 }
                 v2::rdbms_types::ParameterValue::Int16(i) => {
-                    spin::postgres::rdbms_types::ParameterValue::Int16(i)
+                    spin::postgres::postgres::ParameterValue::Int16(i)
                 }
                 v2::rdbms_types::ParameterValue::Int32(i) => {
-                    spin::postgres::rdbms_types::ParameterValue::Int32(i)
+                    spin::postgres::postgres::ParameterValue::Int32(i)
                 }
                 v2::rdbms_types::ParameterValue::Int64(i) => {
-                    spin::postgres::rdbms_types::ParameterValue::Int64(i)
+                    spin::postgres::postgres::ParameterValue::Int64(i)
                 }
                 v2::rdbms_types::ParameterValue::Uint8(u) => {
-                    spin::postgres::rdbms_types::ParameterValue::Uint8(u)
+                    spin::postgres::postgres::ParameterValue::Uint8(u)
                 }
                 v2::rdbms_types::ParameterValue::Uint16(u) => {
-                    spin::postgres::rdbms_types::ParameterValue::Uint16(u)
+                    spin::postgres::postgres::ParameterValue::Uint16(u)
                 }
                 v2::rdbms_types::ParameterValue::Uint32(u) => {
-                    spin::postgres::rdbms_types::ParameterValue::Uint32(u)
+                    spin::postgres::postgres::ParameterValue::Uint32(u)
                 }
                 v2::rdbms_types::ParameterValue::Uint64(u) => {
-                    spin::postgres::rdbms_types::ParameterValue::Uint64(u)
+                    spin::postgres::postgres::ParameterValue::Uint64(u)
                 }
                 v2::rdbms_types::ParameterValue::Floating32(r) => {
-                    spin::postgres::rdbms_types::ParameterValue::Floating32(r)
+                    spin::postgres::postgres::ParameterValue::Floating32(r)
                 }
                 v2::rdbms_types::ParameterValue::Floating64(r) => {
-                    spin::postgres::rdbms_types::ParameterValue::Floating64(r)
+                    spin::postgres::postgres::ParameterValue::Floating64(r)
                 }
                 v2::rdbms_types::ParameterValue::Str(s) => {
-                    spin::postgres::rdbms_types::ParameterValue::Str(s)
+                    spin::postgres::postgres::ParameterValue::Str(s)
                 }
                 v2::rdbms_types::ParameterValue::Binary(b) => {
-                    spin::postgres::rdbms_types::ParameterValue::Binary(b)
+                    spin::postgres::postgres::ParameterValue::Binary(b)
                 }
                 v2::rdbms_types::ParameterValue::DbNull => {
-                    spin::postgres::rdbms_types::ParameterValue::DbNull
+                    spin::postgres::postgres::ParameterValue::DbNull
                 }
             }
         }
@@ -420,44 +352,42 @@ mod rdbms_types {
         }
     }
 
-    impl From<spin::postgres::rdbms_types::Error> for v1::postgres::PgError {
-        fn from(error: spin::postgres::rdbms_types::Error) -> v1::postgres::PgError {
+    impl From<spin::postgres::postgres::Error> for v1::postgres::PgError {
+        fn from(error: spin::postgres::postgres::Error) -> v1::postgres::PgError {
             match error {
-                spin::postgres::rdbms_types::Error::ConnectionFailed(e) => {
+                spin::postgres::postgres::Error::ConnectionFailed(e) => {
                     v1::postgres::PgError::ConnectionFailed(e)
                 }
-                spin::postgres::rdbms_types::Error::BadParameter(e) => {
+                spin::postgres::postgres::Error::BadParameter(e) => {
                     v1::postgres::PgError::BadParameter(e)
                 }
-                spin::postgres::rdbms_types::Error::QueryFailed(e) => {
+                spin::postgres::postgres::Error::QueryFailed(e) => {
                     v1::postgres::PgError::QueryFailed(e)
                 }
-                spin::postgres::rdbms_types::Error::ValueConversionFailed(e) => {
+                spin::postgres::postgres::Error::ValueConversionFailed(e) => {
                     v1::postgres::PgError::ValueConversionFailed(e)
                 }
-                spin::postgres::rdbms_types::Error::Other(e) => {
-                    v1::postgres::PgError::OtherError(e)
-                }
+                spin::postgres::postgres::Error::Other(e) => v1::postgres::PgError::OtherError(e),
             }
         }
     }
 
-    impl From<spin::postgres::rdbms_types::Error> for v2::rdbms_types::Error {
-        fn from(error: spin::postgres::rdbms_types::Error) -> v2::rdbms_types::Error {
+    impl From<spin::postgres::postgres::Error> for v2::rdbms_types::Error {
+        fn from(error: spin::postgres::postgres::Error) -> v2::rdbms_types::Error {
             match error {
-                spin::postgres::rdbms_types::Error::ConnectionFailed(e) => {
+                spin::postgres::postgres::Error::ConnectionFailed(e) => {
                     v2::rdbms_types::Error::ConnectionFailed(e)
                 }
-                spin::postgres::rdbms_types::Error::BadParameter(e) => {
+                spin::postgres::postgres::Error::BadParameter(e) => {
                     v2::rdbms_types::Error::BadParameter(e)
                 }
-                spin::postgres::rdbms_types::Error::QueryFailed(e) => {
+                spin::postgres::postgres::Error::QueryFailed(e) => {
                     v2::rdbms_types::Error::QueryFailed(e)
                 }
-                spin::postgres::rdbms_types::Error::ValueConversionFailed(e) => {
+                spin::postgres::postgres::Error::ValueConversionFailed(e) => {
                     v2::rdbms_types::Error::ValueConversionFailed(e)
                 }
-                spin::postgres::rdbms_types::Error::Other(e) => v2::rdbms_types::Error::Other(e),
+                spin::postgres::postgres::Error::Other(e) => v2::rdbms_types::Error::Other(e),
             }
         }
     }
diff --git a/crates/world/src/lib.rs b/crates/world/src/lib.rs
index 39f843b5d..4b62da5d7 100644
--- a/crates/world/src/lib.rs
+++ b/crates/world/src/lib.rs
@@ -29,7 +29,7 @@ wasmtime::component::bindgen!({
         "fermyon:spin/sqlite@2.0.0/error" => v2::sqlite::Error,
         "fermyon:spin/sqlite/error" => v1::sqlite::Error,
         "fermyon:spin/variables@2.0.0/error" => v2::variables::Error,
-        "spin:postgres/rdbms-types/error" => spin::postgres::rdbms_types::Error,
+        "spin:postgres/postgres/error" => spin::postgres::postgres::Error,
     },
     trappable_imports: true,
 });
diff --git a/wit/deps/spin-postgres@3.0.0/postgres.wit b/wit/deps/spin-postgres@3.0.0/postgres.wit
index 81341095e..35134959e 100644
--- a/wit/deps/spin-postgres@3.0.0/postgres.wit
+++ b/wit/deps/spin-postgres@3.0.0/postgres.wit
@@ -1,7 +1,96 @@
 package spin:postgres@3.0.0;
 
 interface postgres {
-  use rdbms-types.{parameter-value, row-set, error};
+  /// Errors related to interacting with a database.
+  variant error {
+      connection-failed(string),
+      bad-parameter(string),
+      query-failed(string),
+      value-conversion-failed(string),
+      other(string)
+  }
+
+  /// Data types for a database column
+  enum db-data-type {
+      boolean,
+      int8,
+      int16,
+      int32,
+      int64,
+      uint8,
+      uint16,
+      uint32,
+      uint64,
+      floating32,
+      floating64,
+      str,
+      binary,
+      date,
+      time,
+      datetime,
+      timestamp,
+      other,
+  }
+
+  /// Database values
+  variant db-value {
+      boolean(bool),
+      int8(s8),
+      int16(s16),
+      int32(s32),
+      int64(s64),
+      uint8(u8),
+      uint16(u16),
+      uint32(u32),
+      uint64(u64),
+      floating32(float32),
+      floating64(float64),
+      str(string),
+      binary(list<u8>),
+      date(tuple<s32, u8, u8>), // (year, month, day)
+      time(tuple<u8, u8, u8, u32>), // (hour, minute, second, nanosecond)
+      datetime(tuple<s32, u8, u8, u8, u8, u8, u32>), // (year, month, day, hour, minute, second, nanosecond)
+      timestamp(s64), // Unix timestamp (seconds since epoch)
+      db-null,
+      unsupported,
+  }
+
+  /// Values used in parameterized queries
+  variant parameter-value {
+      boolean(bool),
+      int8(s8),
+      int16(s16),
+      int32(s32),
+      int64(s64),
+      uint8(u8),
+      uint16(u16),
+      uint32(u32),
+      uint64(u64),
+      floating32(float32),
+      floating64(float64),
+      str(string),
+      binary(list<u8>),
+      date(tuple<s32, u8, u8>), // (year, month, day)
+      time(tuple<u8, u8, u8, u32>), // (hour, minute, second, nanosecond)
+      datetime(tuple<s32, u8, u8, u8, u8, u8, u32>), // (year, month, day, hour, minute, second, nanosecond)
+      timestamp(s64), // Unix timestamp (seconds since epoch)
+      db-null,
+  }
+
+  /// A database column
+  record column {
+      name: string,
+      data-type: db-data-type,
+  }
+
+  /// A database row
+  type row = list<db-value>;
+
+  /// A set of database rows
+  record row-set {
+      columns: list<column>,
+      rows: list<row>,
+  }
 
   /// A connection to a postgres database.
   resource connection {
diff --git a/wit/deps/spin-postgres@3.0.0/rdbms-types.wit b/wit/deps/spin-postgres@3.0.0/rdbms-types.wit
deleted file mode 100644
index 3704ea230..000000000
--- a/wit/deps/spin-postgres@3.0.0/rdbms-types.wit
+++ /dev/null
@@ -1,92 +0,0 @@
-interface rdbms-types {
-  /// Errors related to interacting with a database.
-  variant error {
-      connection-failed(string),
-      bad-parameter(string),
-      query-failed(string),
-      value-conversion-failed(string),
-      other(string)
-  }
-
-  /// Data types for a database column
-  enum db-data-type {
-      boolean,
-      int8,
-      int16,
-      int32,
-      int64,
-      uint8,
-      uint16,
-      uint32,
-      uint64,
-      floating32,
-      floating64,
-      str,
-      binary,
-      date,
-      time,
-      datetime,
-      timestamp,
-      other,
-  }
-
-  /// Database values
-  variant db-value {
-      boolean(bool),
-      int8(s8),
-      int16(s16),
-      int32(s32),
-      int64(s64),
-      uint8(u8),
-      uint16(u16),
-      uint32(u32),
-      uint64(u64),
-      floating32(float32),
-      floating64(float64),
-      str(string),
-      binary(list<u8>),
-      date(tuple<s32, u8, u8>), // (year, month, day)
-      time(tuple<u8, u8, u8, u32>), // (hour, minute, second, nanosecond)
-      datetime(tuple<s32, u8, u8, u8, u8, u8, u32>), // (year, month, day, hour, minute, second, nanosecond)
-      timestamp(s64), // Unix timestamp (seconds since epoch)
-      db-null,
-      unsupported,
-  }
-
-  /// Values used in parameterized queries
-  variant parameter-value {
-      boolean(bool),
-      int8(s8),
-      int16(s16),
-      int32(s32),
-      int64(s64),
-      uint8(u8),
-      uint16(u16),
-      uint32(u32),
-      uint64(u64),
-      floating32(float32),
-      floating64(float64),
-      str(string),
-      binary(list<u8>),
-      date(tuple<s32, u8, u8>), // (year, month, day)
-      time(tuple<u8, u8, u8, u32>), // (hour, minute, second, nanosecond)
-      datetime(tuple<s32, u8, u8, u8, u8, u8, u32>), // (year, month, day, hour, minute, second, nanosecond)
-      timestamp(s64), // Unix timestamp (seconds since epoch)
-      db-null,
-  }
-
-  /// A database column
-  record column {
-      name: string,
-      data-type: db-data-type,
-  }
-
-  /// A database row
-  type row = list<db-value>;
-
-  /// A set of database rows
-  record row-set {
-      columns: list<column>,
-      rows: list<row>,
-  }
-}