wami 0.17.1

//! WAMI - Who Am I: Multicloud Identity and Access Management library for Rust
//!
//! This library provides a multicloud implementation of Identity and Access Management (IAM),
//! Security Token Service (STS), and Single Sign-On Admin operations. It's designed to work
//! across multiple cloud providers (AWS, GCP, Azure, and custom platforms) and can be used
//! for testing, development, or as a unified identity layer for multicloud environments.
//!
//! ## Features
//!
//! - **🌐 Multicloud Support**: AWS, GCP, Azure, and custom identity providers
//! - **IAM Operations**: Complete user, group, role, and policy management
//! - **STS Operations**: Temporary credentials and identity inspection
//! - **SSO Admin Operations**: Permission sets, assignments, and instances
//! - **Pluggable Storage**: In-memory, database, or cloud-native backends
//! - **Async API**: All operations are asynchronous for better performance
//! - **Type Safety**: Strongly typed requests and responses
//!
//! ## Example
//!
//! ```rust
//! use wami::store::memory::InMemoryStore;
//! use wami::store::{Store, traits::UserStore};
//! use wami::arn::{TenantPath, WamiArn};
//! use wami::context::WamiContext;
//! use wami::wami::identity::user::builder::build_user;
//!
//! #[tokio::main]
//! async fn main() -> Result<(), Box<dyn std::error::Error>> {
//!     // Initialize logging
//!     env_logger::init();
//!     
//!     // Initialize store
//!     let mut store = InMemoryStore::default();
//!     
//!     // Create WamiContext
//!     let context = WamiContext::builder()
//!         .instance_id("123456789012")
//!         .tenant_path(TenantPath::single(0))
//!         .caller_arn(
//!             WamiArn::builder()
//!                 .service(wami::arn::Service::Iam)
//!                 .tenant_path(TenantPath::single(0))
//!                 .wami_instance("123456789012")
//!                 .resource("user", "admin")
//!                 .build()?,
//!         )
//!         .is_root(false)
//!         .build()?;
//!     
//!     // Build a user using pure functions
//!     let user = build_user(
//!         "alice".to_string(),
//!         Some("/".to_string()),
//!         &context,
//!     )?;
//!     
//!     // Store the user
//!     let created_user = store.wami_store().await?.create_user(user).await?;
//!     println!("Created user: {}", created_user.user_name);
//!     println!("User ARN: {}", created_user.arn);
//!     
//!     // Retrieve the user
//!     let retrieved = store.wami_store().await?.get_user("alice").await?;
//!     if let Some(user) = retrieved {
//!         println!("Retrieved user: {}", user.user_name);
//!     }
//!     
//!     Ok(())
//! }
//! ```

pub mod service;
pub mod store;
pub mod wami;

// Re-export core primitives from the dedicated crate
pub use wami_core::arn;
pub use wami_core::context;
pub use wami_core::error;
pub use wami_core::types;

// Re-export main types for convenience
pub use wami_core::error::{AmiError, OptionExt, Result};
pub use wami_core::types::{
    AmiResponse, AwsConfig, PaginationParams, PolicyDocument, PolicyStatement, Tag,
};

// Re-export ARN types
pub use wami_core::arn::{
    available_providers, get_transformer, parse_arn, ArnBuilder, ArnParseError, ArnTransformer,
    CloudMapping, ProviderArnInfo, Resource, Service, TenantPath, WamiArn,
};
// Behind their provider's feature, all off by default.
#[cfg(feature = "aws")]
pub use wami_core::arn::AwsArnTransformer;
#[cfg(feature = "azure")]
pub use wami_core::arn::AzureArnTransformer;
#[cfg(feature = "gcp")]
pub use wami_core::arn::GcpArnTransformer;
#[cfg(feature = "scaleway")]
pub use wami_core::arn::ScalewayArnTransformer;

// Re-export context types
pub use wami_core::context::{SessionInfo, WamiContext};

// Re-export store traits and implementations
pub use store::memory::InMemoryStore;
pub use store::{SsoAdminStore, Store, StsStore, WamiStore};

// Re-export provider types
pub mod credentials;
pub mod provider;
pub use provider::ProviderConfig;
// Re-export service layer
pub use service::{
    hash_secret, verify_secret, AccessKeyService, AccountAssignmentService, ApplicationService,
    AssumeRoleService, AttachmentService, AuthenticationService, AuthorizationService,
    CredentialReportService, EvaluationService, FederationService, GroupService, IdentityService,
    InlinePolicyService, InstanceService as SsoInstanceService, LoginProfileService,
    MfaDeviceService, OAuthService, PermissionSetService, PolicyService, RoleService,
    ServerCertificateService, ServiceCredentialService, ServiceLinkedRoleService, SessionService,
    SessionTokenService, SigningCertificateService, TenantService, TrustedTokenIssuerService,
    UserService,
};

// Re-export WAMI modules for convenience (Legacy compatibility)
pub use wami::{instance, sso_admin, sts, tenant};

// Re-export instance types
pub use wami::instance::{InstanceBootstrap, RoleSeed, RootCredentials};

// Re-export identity types
pub use wami::identity::{Group, Role, RootUser, User};

// Re-export credential types
pub use credentials::{
    AccessKey, LoginProfile, MfaDevice, ServerCertificate, ServiceSpecificCredential,
};
// pub use credentials::server_certificate::ServerCertificateMetadata; // TODO: fix path

// Re-export policy types
pub use wami::policies::Policy;

// Re-export report types
pub use wami::reports::CredentialReport;

// Re-export STS types
pub use wami::sts::{Credentials, StsSession};

// Re-export SSO Admin types (TODO: update when sso_admin is refactored)
// pub use wami::sso_admin::{AccountAssignment, Application, PermissionSet, SsoInstance, TrustedTokenIssuer};

// Re-export Tenant types
pub use wami::tenant::{
    check_tenant_permission, BillingInfo, QuotaMode, Tenant, TenantAction, TenantId, TenantQuotas,
    TenantStatus, TenantType, TenantUsage,
};

// Legacy IAM module alias
// #[deprecated(since = "0.2.0", note = "Use wami::identity, wami::credentials, etc. instead")]
// pub use wami::iam; // Temporarily removed to avoid warnings

// Re-export request/response types (updated paths)
pub use credentials::access_key::{
    AccessKeyLastUsed, CreateAccessKeyRequest, ListAccessKeysRequest, ListAccessKeysResponse,
    UpdateAccessKeyRequest,
};
pub use credentials::login_profile::{
    CreateLoginProfileRequest, GetLoginProfileRequest, UpdateLoginProfileRequest,
};
pub use credentials::mfa_device::{EnableMfaDeviceRequest, ListMfaDevicesRequest};
pub use credentials::server_certificate::{
    DeleteServerCertificateRequest, GetServerCertificateRequest, GetServerCertificateResponse,
    ListServerCertificatesRequest, ListServerCertificatesResponse, UpdateServerCertificateRequest,
    UploadServerCertificateRequest, UploadServerCertificateResponse,
};
pub use credentials::service_credential::{
    CreateServiceSpecificCredentialRequest, CreateServiceSpecificCredentialResponse,
    DeleteServiceSpecificCredentialRequest, ListServiceSpecificCredentialsRequest,
    ListServiceSpecificCredentialsResponse, ResetServiceSpecificCredentialRequest,
    ResetServiceSpecificCredentialResponse, UpdateServiceSpecificCredentialRequest,
};
pub use credentials::signing_certificate::{
    CertificateStatus, DeleteSigningCertificateRequest, ListSigningCertificatesRequest,
    ListSigningCertificatesResponse, SigningCertificate, UpdateSigningCertificateRequest,
    UploadSigningCertificateRequest, UploadSigningCertificateResponse,
};
pub use wami::identity::group::{
    CreateGroupRequest, ListGroupsRequest, ListGroupsResponse, UpdateGroupRequest,
};
pub use wami::identity::role::{
    CreateRoleRequest, ListRolesRequest, ListRolesResponse, UpdateRoleRequest,
};
pub use wami::identity::service_linked_role::{
    CreateServiceLinkedRoleRequest, CreateServiceLinkedRoleResponse,
    DeleteServiceLinkedRoleRequest, DeleteServiceLinkedRoleResponse, DeletionTaskFailureReason,
    DeletionTaskInfo, DeletionTaskStatus, GetServiceLinkedRoleDeletionStatusRequest,
    GetServiceLinkedRoleDeletionStatusResponse, RoleUsageType,
};
pub use wami::identity::user::{
    CreateUserRequest, ListUsersRequest, ListUsersResponse, UpdateUserRequest,
};
pub use wami::policies::attachment::{
    AttachGroupPolicyRequest, AttachGroupPolicyResponse, AttachRolePolicyRequest,
    AttachRolePolicyResponse, AttachUserPolicyRequest, AttachUserPolicyResponse, AttachedPolicy,
    DetachGroupPolicyRequest, DetachGroupPolicyResponse, DetachRolePolicyRequest,
    DetachRolePolicyResponse, DetachUserPolicyRequest, DetachUserPolicyResponse,
    ListAttachedGroupPoliciesRequest, ListAttachedGroupPoliciesResponse,
    ListAttachedRolePoliciesRequest, ListAttachedRolePoliciesResponse,
    ListAttachedUserPoliciesRequest, ListAttachedUserPoliciesResponse,
};
pub use wami::policies::evaluation::{
    ContextEntry, EvaluationResult, SimulateCustomPolicyRequest, SimulatePolicyResponse,
    SimulatePrincipalPolicyRequest, StatementMatch,
};
pub use wami::policies::inline::{
    DeleteGroupPolicyRequest, DeleteGroupPolicyResponse, DeleteRolePolicyRequest,
    DeleteRolePolicyResponse, DeleteUserPolicyRequest, DeleteUserPolicyResponse,
    GetGroupPolicyRequest, GetGroupPolicyResponse, GetRolePolicyRequest, GetRolePolicyResponse,
    GetUserPolicyRequest, GetUserPolicyResponse, InlinePolicy, ListGroupPoliciesRequest,
    ListGroupPoliciesResponse, ListRolePoliciesRequest, ListRolePoliciesResponse,
    ListUserPoliciesRequest, ListUserPoliciesResponse, PutGroupPolicyRequest,
    PutGroupPolicyResponse, PutRolePolicyRequest, PutRolePolicyResponse, PutUserPolicyRequest,
    PutUserPolicyResponse,
};
pub use wami::policies::policy::{
    CreatePolicyRequest, ListPoliciesRequest, ListPoliciesResponse, UpdatePolicyRequest,
};
pub use wami::reports::credential_report::{
    AccountSummaryMap, CredentialReport as CredentialReportType, GenerateCredentialReportRequest,
    GenerateCredentialReportResponse, GetAccountSummaryRequest, GetAccountSummaryResponse,
    GetCredentialReportRequest, GetCredentialReportResponse, ReportState,
};
pub use wami::tags::{ListResourceTagsRequest, TagResourceRequest, UntagResourceRequest};
// SSO Admin request types (to be re-exported when needed)
// pub use sso_admin::{CreateAccountAssignmentRequest, CreatePermissionSetRequest};
pub use sts::{AssumeRoleRequest, GetSessionTokenRequest};
// pub use sts::{GetFederationTokenRequest};  // Re-export when needed

// /// Initialize all clients with in-memory storage
// /// TEMPORARILY DISABLED during pure functions refactor
// pub fn initialize_clients_with_memory_store() -> (
//     IamClient<InMemoryStore>,
//     StsClient<InMemoryStore>,
//     SsoAdminClient<InMemoryStore>,
//     TenantClient<InMemoryStore>,
// ) {
//     let store = InMemoryStore::new();
//     let iam_client = IamClient::new(store.clone());
//     let sts_client = StsClient::new(store.clone());
//     let sso_client = SsoAdminClient::new(store.clone());
//     let tenant_client = TenantClient::new(store, "admin@example.com".to_string());
//
//     (iam_client, sts_client, sso_client, tenant_client)
// }

/// Create a new in-memory store
pub fn create_memory_store() -> InMemoryStore {
    InMemoryStore::new()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_create_memory_store() {
        let _store = create_memory_store();
        // Just verify it can be created
    }
}

// Note: Provider-specific functionality has been removed from the unified store.
// Resources now carry their own provider-specific information (ARNs, account IDs, etc.).
// If you need provider-specific functionality, use the client-level providers.

// /// Type alias for convenience when using in-memory storage
// /// TODO: Rebuild these with service layer
// pub type MemoryIamClient = IamClient<InMemoryStore>;
// pub type MemoryStsClient = StsClient<InMemoryStore>;
// pub type MemorySsoAdminClient = SsoAdminClient<InMemoryStore>;
// pub type MemoryTenantClient = TenantClient<InMemoryStore>;