build.ps1

@@ -108,7 +108,12 @@ function Write-Manifest {
         'Get-InfisicalProject',
         'New-InfisicalProject',
         'Update-InfisicalProject',
-        'Remove-InfisicalProject'
+        'Remove-InfisicalProject',
+        'Get-InfisicalEnvironments',
+        'Get-InfisicalEnvironment',
+        'New-InfisicalEnvironment',
+        'Update-InfisicalEnvironment',
+        'Remove-InfisicalEnvironment'
     )
     AliasesToExport      = @()
     VariablesToExport    = @()
@@ -168,7 +173,7 @@ if (`$null -eq `$manifest) {
 
 Import-Module -Name '$($ModuleDirectory.FullName)' -Force
 
-`$cmds = @('Connect-Infisical','Disconnect-Infisical','Get-InfisicalSecrets','Get-InfisicalSecret','ConvertTo-InfisicalSecretDictionary','Export-InfisicalSecrets','Get-InfisicalProjects','Get-InfisicalProject','New-InfisicalProject','Update-InfisicalProject','Remove-InfisicalProject')
+`$cmds = @('Connect-Infisical','Disconnect-Infisical','Get-InfisicalSecrets','Get-InfisicalSecret','ConvertTo-InfisicalSecretDictionary','Export-InfisicalSecrets','Get-InfisicalProjects','Get-InfisicalProject','New-InfisicalProject','Update-InfisicalProject','Remove-InfisicalProject','Get-InfisicalEnvironments','Get-InfisicalEnvironment','New-InfisicalEnvironment','Update-InfisicalEnvironment','Remove-InfisicalEnvironment')
 foreach (`$c in `$cmds) {
     if (-not (Get-Command -Name `$c -Module PSInfisicalAPI -ErrorAction SilentlyContinue)) {
         throw "Cmdlet not found: `$c"

src/PSInfisicalAPI.Tests/EnvironmentMapperTests.cs

@@ -0,0 +1,77 @@
+using System.Reflection;
+using PSInfisicalAPI.Models;
+using Xunit;
+
+namespace PSInfisicalAPI.Tests
+{
+    public class EnvironmentMapperTests
+    {
+        private static readonly System.Type MapperType = typeof(PSInfisicalAPI.Connections.InfisicalConnection).Assembly
+            .GetType("PSInfisicalAPI.Environments.InfisicalEnvironmentMapper", true);
+
+        private static readonly System.Type DtoType = typeof(PSInfisicalAPI.Connections.InfisicalConnection).Assembly
+            .GetType("PSInfisicalAPI.Environments.InfisicalEnvironmentResponseDto", true);
+
+        private static InfisicalEnvironment InvokeMap(object dto, string fallbackProjectId)
+        {
+            MethodInfo map = MapperType.GetMethod("Map", BindingFlags.Public | BindingFlags.Static);
+            return (InfisicalEnvironment)map.Invoke(null, new object[] { dto, fallbackProjectId });
+        }
+
+        [Fact]
+        public void Map_Null_Returns_Null()
+        {
+            Assert.Null(InvokeMap(null, "proj-x"));
+        }
+
+        [Fact]
+        public void Map_Populates_Fields_With_Explicit_ProjectId()
+        {
+            object dto = System.Activator.CreateInstance(DtoType);
+            DtoType.GetProperty("Id").SetValue(dto, "env-001");
+            DtoType.GetProperty("Name").SetValue(dto, "Production");
+            DtoType.GetProperty("Slug").SetValue(dto, "prod");
+            DtoType.GetProperty("Position").SetValue(dto, 1);
+            DtoType.GetProperty("ProjectId").SetValue(dto, "proj-001");
+
+            InfisicalEnvironment env = InvokeMap(dto, "fallback-proj");
+
+            Assert.Equal("env-001", env.Id);
+            Assert.Equal("Production", env.Name);
+            Assert.Equal("prod", env.Slug);
+            Assert.Equal(1, env.Position);
+            Assert.Equal("proj-001", env.ProjectId);
+        }
+
+        [Fact]
+        public void Map_Uses_WorkspaceId_When_ProjectId_Empty()
+        {
+            object dto = System.Activator.CreateInstance(DtoType);
+            DtoType.GetProperty("Id").SetValue(dto, "env-002");
+            DtoType.GetProperty("WorkspaceId").SetValue(dto, "wks-002");
+
+            InfisicalEnvironment env = InvokeMap(dto, "fallback-proj");
+            Assert.Equal("wks-002", env.ProjectId);
+        }
+
+        [Fact]
+        public void Map_Uses_Fallback_When_No_ProjectId_Or_WorkspaceId()
+        {
+            object dto = System.Activator.CreateInstance(DtoType);
+            DtoType.GetProperty("Id").SetValue(dto, "env-003");
+
+            InfisicalEnvironment env = InvokeMap(dto, "fallback-proj");
+            Assert.Equal("fallback-proj", env.ProjectId);
+        }
+
+        [Fact]
+        public void Map_Falls_Back_To_InternalId_For_Id()
+        {
+            object dto = System.Activator.CreateInstance(DtoType);
+            DtoType.GetProperty("InternalId").SetValue(dto, "internal-env");
+
+            InfisicalEnvironment env = InvokeMap(dto, "p");
+            Assert.Equal("internal-env", env.Id);
+        }
+    }
+}

src/PSInfisicalAPI/Cmdlets/GetInfisicalEnvironmentCmdlet.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Management.Automation;
+using PSInfisicalAPI.Connections;
+using PSInfisicalAPI.Environments;
+using PSInfisicalAPI.Models;
+
+namespace PSInfisicalAPI.Cmdlets
+{
+    [Cmdlet(VerbsCommon.Get, "InfisicalEnvironment")]
+    [OutputType(typeof(InfisicalEnvironment))]
+    public sealed class GetInfisicalEnvironmentCmdlet : InfisicalCmdletBase
+    {
+        [Parameter(Mandatory = true, ValueFromPipelineByPropertyName = true, Position = 0)]
+        [Alias("Slug", "Id", "Environment")]
+        public string EnvironmentSlugOrId { get; set; }
+
+        [Parameter] public string ProjectId { get; set; }
+
+        protected override void ProcessRecord()
+        {
+            try
+            {
+                InfisicalConnection connection = InfisicalSessionManager.RequireCurrent();
+                InfisicalEnvironmentClient client = new InfisicalEnvironmentClient(HttpClient, Logger);
+                InfisicalEnvironment env = client.Retrieve(connection, ProjectId, EnvironmentSlugOrId);
+                if (env != null)
+                {
+                    WriteObject(env);
+                }
+            }
+            catch (Exception exception)
+            {
+                ThrowTerminatingForException("GetInfisicalEnvironmentCmdlet", "RetrieveEnvironment", exception);
+            }
+        }
+    }
+}

src/PSInfisicalAPI/Cmdlets/GetInfisicalEnvironmentsCmdlet.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Management.Automation;
+using PSInfisicalAPI.Connections;
+using PSInfisicalAPI.Environments;
+using PSInfisicalAPI.Models;
+
+namespace PSInfisicalAPI.Cmdlets
+{
+    [Cmdlet(VerbsCommon.Get, "InfisicalEnvironments")]
+    [OutputType(typeof(InfisicalEnvironment))]
+    public sealed class GetInfisicalEnvironmentsCmdlet : InfisicalCmdletBase
+    {
+        [Parameter] public string ProjectId { get; set; }
+
+        protected override void ProcessRecord()
+        {
+            try
+            {
+                InfisicalConnection connection = InfisicalSessionManager.RequireCurrent();
+                InfisicalEnvironmentClient client = new InfisicalEnvironmentClient(HttpClient, Logger);
+                InfisicalEnvironment[] envs = client.List(connection, ProjectId);
+                foreach (InfisicalEnvironment env in envs)
+                {
+                    WriteObject(env);
+                }
+            }
+            catch (Exception exception)
+            {
+                ThrowTerminatingForException("GetInfisicalEnvironmentsCmdlet", "ListEnvironments", exception);
+            }
+        }
+    }
+}

src/PSInfisicalAPI/Cmdlets/NewInfisicalEnvironmentCmdlet.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Management.Automation;
+using PSInfisicalAPI.Connections;
+using PSInfisicalAPI.Environments;
+using PSInfisicalAPI.Models;
+
+namespace PSInfisicalAPI.Cmdlets
+{
+    [Cmdlet(VerbsCommon.New, "InfisicalEnvironment", SupportsShouldProcess = true)]
+    [OutputType(typeof(InfisicalEnvironment))]
+    public sealed class NewInfisicalEnvironmentCmdlet : InfisicalCmdletBase
+    {
+        [Parameter(Mandatory = true, Position = 0)] public string Name { get; set; }
+        [Parameter(Mandatory = true, Position = 1)] public string Slug { get; set; }
+        [Parameter] public string ProjectId { get; set; }
+        [Parameter] public int? Position { get; set; }
+
+        protected override void ProcessRecord()
+        {
+            try
+            {
+                if (!ShouldProcess(Slug, "Create Infisical environment"))
+                {
+                    return;
+                }
+
+                InfisicalConnection connection = InfisicalSessionManager.RequireCurrent();
+                InfisicalEnvironmentClient client = new InfisicalEnvironmentClient(HttpClient, Logger);
+                InfisicalEnvironment env = client.Create(connection, ProjectId, Name, Slug, Position);
+                if (env != null)
+                {
+                    WriteObject(env);
+                }
+            }
+            catch (Exception exception)
+            {
+                ThrowTerminatingForException("NewInfisicalEnvironmentCmdlet", "CreateEnvironment", exception);
+            }
+        }
+    }
+}

src/PSInfisicalAPI/Cmdlets/RemoveInfisicalEnvironmentCmdlet.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Management.Automation;
+using PSInfisicalAPI.Connections;
+using PSInfisicalAPI.Environments;
+
+namespace PSInfisicalAPI.Cmdlets
+{
+    [Cmdlet(VerbsCommon.Remove, "InfisicalEnvironment", SupportsShouldProcess = true, ConfirmImpact = ConfirmImpact.High)]
+    public sealed class RemoveInfisicalEnvironmentCmdlet : InfisicalCmdletBase
+    {
+        [Parameter(Mandatory = true, ValueFromPipelineByPropertyName = true, Position = 0)]
+        [Alias("Id")]
+        public string EnvironmentId { get; set; }
+
+        [Parameter] public string ProjectId { get; set; }
+        [Parameter] public SwitchParameter PassThru { get; set; }
+
+        protected override void ProcessRecord()
+        {
+            try
+            {
+                if (!ShouldProcess(EnvironmentId, "Remove Infisical environment"))
+                {
+                    return;
+                }
+
+                InfisicalConnection connection = InfisicalSessionManager.RequireCurrent();
+                InfisicalEnvironmentClient client = new InfisicalEnvironmentClient(HttpClient, Logger);
+                client.Delete(connection, ProjectId, EnvironmentId);
+
+                if (PassThru.IsPresent)
+                {
+                    WriteObject(EnvironmentId);
+                }
+            }
+            catch (Exception exception)
+            {
+                ThrowTerminatingForException("RemoveInfisicalEnvironmentCmdlet", "DeleteEnvironment", exception);
+            }
+        }
+    }
+}

src/PSInfisicalAPI/Cmdlets/UpdateInfisicalEnvironmentCmdlet.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Management.Automation;
+using PSInfisicalAPI.Connections;
+using PSInfisicalAPI.Environments;
+using PSInfisicalAPI.Models;
+
+namespace PSInfisicalAPI.Cmdlets
+{
+    [Cmdlet(VerbsData.Update, "InfisicalEnvironment", SupportsShouldProcess = true)]
+    [OutputType(typeof(InfisicalEnvironment))]
+    public sealed class UpdateInfisicalEnvironmentCmdlet : InfisicalCmdletBase
+    {
+        [Parameter(Mandatory = true, ValueFromPipelineByPropertyName = true, Position = 0)]
+        [Alias("Id")]
+        public string EnvironmentId { get; set; }
+
+        [Parameter] public string ProjectId { get; set; }
+        [Parameter] public string Name { get; set; }
+        [Parameter] public string Slug { get; set; }
+        [Parameter] public int? Position { get; set; }
+
+        protected override void ProcessRecord()
+        {
+            try
+            {
+                if (!ShouldProcess(EnvironmentId, "Update Infisical environment"))
+                {
+                    return;
+                }
+
+                InfisicalConnection connection = InfisicalSessionManager.RequireCurrent();
+                InfisicalEnvironmentClient client = new InfisicalEnvironmentClient(HttpClient, Logger);
+                InfisicalEnvironment env = client.Update(connection, ProjectId, EnvironmentId, Name, Slug, Position);
+                if (env != null)
+                {
+                    WriteObject(env);
+                }
+            }
+            catch (Exception exception)
+            {
+                ThrowTerminatingForException("UpdateInfisicalEnvironmentCmdlet", "UpdateEnvironment", exception);
+            }
+        }
+    }
+}

src/PSInfisicalAPI/Environments/InfisicalEnvironmentClient.cs

@@ -0,0 +1,166 @@
+using System;
+using System.Collections.Generic;
+using PSInfisicalAPI.Connections;
+using PSInfisicalAPI.Endpoints;
+using PSInfisicalAPI.Errors;
+using PSInfisicalAPI.Http;
+using PSInfisicalAPI.Logging;
+using PSInfisicalAPI.Models;
+using PSInfisicalAPI.Serialization;
+
+namespace PSInfisicalAPI.Environments
+{
+    public sealed class InfisicalEnvironmentClient
+    {
+        private const string Component = "EnvironmentClient";
+
+        private readonly IInfisicalLogger _logger;
+        private readonly JsonInfisicalSerializer _serializer;
+        private readonly InfisicalApiInvoker _invoker;
+
+        public InfisicalEnvironmentClient(IInfisicalHttpClient httpClient, IInfisicalLogger logger)
+        {
+            if (httpClient == null) { throw new ArgumentNullException(nameof(httpClient)); }
+            _logger = logger ?? NullInfisicalLogger.Instance;
+            _serializer = new JsonInfisicalSerializer();
+            _invoker = new InfisicalApiInvoker(httpClient);
+        }
+
+        public InfisicalEnvironment[] List(InfisicalConnection connection, string projectId)
+        {
+            if (connection == null) { throw new ArgumentNullException(nameof(connection)); }
+            string resolvedProjectId = FirstNonEmpty(projectId, connection.ProjectId);
+            if (string.IsNullOrEmpty(resolvedProjectId)) { throw new InfisicalConfigurationException("ProjectId is required."); }
+
+            Dictionary<string, string> pathParameters = new Dictionary<string, string> { { "projectId", resolvedProjectId } };
+
+            try
+            {
+                _logger.Information(Component, "Attempting to list Infisical environments. Please Wait...");
+                InfisicalHttpResponse response = _invoker.Invoke(connection, InfisicalEndpointNames.ListEnvironments, "ListEnvironments", pathParameters, null, null);
+                InfisicalEnvironmentWorkspaceWrapperDto dto = _serializer.Deserialize<InfisicalEnvironmentWorkspaceWrapperDto>(response.Body);
+                response.Clear();
+
+                InfisicalEnvironmentWorkspaceDto workspace = dto != null ? (dto.Workspace ?? dto.Project) : null;
+                List<InfisicalEnvironmentResponseDto> envs = workspace != null ? workspace.Environments : null;
+                InfisicalEnvironment[] mapped = InfisicalEnvironmentMapper.MapMany(envs, resolvedProjectId);
+                _logger.Information(Component, "Infisical environment list retrieval was successful.");
+                return mapped;
+            }
+            catch (Exception)
+            {
+                _logger.Error(Component, "Infisical environment list retrieval failed.");
+                throw;
+            }
+        }
+
+        public InfisicalEnvironment Retrieve(InfisicalConnection connection, string projectId, string environmentSlugOrId)
+        {
+            if (connection == null) { throw new ArgumentNullException(nameof(connection)); }
+            string resolvedProjectId = FirstNonEmpty(projectId, connection.ProjectId);
+            if (string.IsNullOrEmpty(resolvedProjectId)) { throw new InfisicalConfigurationException("ProjectId is required."); }
+            if (string.IsNullOrEmpty(environmentSlugOrId)) { throw new InfisicalConfigurationException("Environment is required."); }
+
+            InfisicalEnvironment[] all = List(connection, resolvedProjectId);
+            foreach (InfisicalEnvironment env in all)
+            {
+                if (string.Equals(env.Id, environmentSlugOrId, StringComparison.OrdinalIgnoreCase) ||
+                    string.Equals(env.Slug, environmentSlugOrId, StringComparison.OrdinalIgnoreCase))
+                {
+                    return env;
+                }
+            }
+
+            return null;
+        }
+
+        public InfisicalEnvironment Create(InfisicalConnection connection, string projectId, string name, string slug, int? position)
+        {
+            if (connection == null) { throw new ArgumentNullException(nameof(connection)); }
+            string resolvedProjectId = FirstNonEmpty(projectId, connection.ProjectId);
+            if (string.IsNullOrEmpty(resolvedProjectId)) { throw new InfisicalConfigurationException("ProjectId is required."); }
+            if (string.IsNullOrEmpty(name)) { throw new InfisicalConfigurationException("Name is required."); }
+            if (string.IsNullOrEmpty(slug)) { throw new InfisicalConfigurationException("Slug is required."); }
+
+            Dictionary<string, string> pathParameters = new Dictionary<string, string> { { "projectId", resolvedProjectId } };
+            InfisicalEnvironmentCreateRequestDto request = new InfisicalEnvironmentCreateRequestDto { Name = name, Slug = slug, Position = position };
+            string body = _serializer.Serialize(request);
+
+            try
+            {
+                _logger.Information(Component, string.Concat("Attempting to create Infisical environment '", slug, "'. Please Wait..."));
+                InfisicalHttpResponse response = _invoker.Invoke(connection, InfisicalEndpointNames.CreateEnvironment, "CreateEnvironment", pathParameters, null, body);
+                InfisicalEnvironmentSingleResponseDto dto = _serializer.Deserialize<InfisicalEnvironmentSingleResponseDto>(response.Body);
+                response.Clear();
+
+                InfisicalEnvironment mapped = InfisicalEnvironmentMapper.Map(dto != null ? dto.Environment : null, resolvedProjectId);
+                _logger.Information(Component, "Infisical environment creation was successful.");
+                return mapped;
+            }
+            catch (Exception)
+            {
+                _logger.Error(Component, "Infisical environment creation failed.");
+                throw;
+            }
+        }
+
+        public InfisicalEnvironment Update(InfisicalConnection connection, string projectId, string environmentId, string name, string slug, int? position)
+        {
+            if (connection == null) { throw new ArgumentNullException(nameof(connection)); }
+            string resolvedProjectId = FirstNonEmpty(projectId, connection.ProjectId);
+            if (string.IsNullOrEmpty(resolvedProjectId)) { throw new InfisicalConfigurationException("ProjectId is required."); }
+            if (string.IsNullOrEmpty(environmentId)) { throw new InfisicalConfigurationException("EnvironmentId is required."); }
+
+            Dictionary<string, string> pathParameters = new Dictionary<string, string> { { "projectId", resolvedProjectId }, { "environmentId", environmentId } };
+            InfisicalEnvironmentUpdateRequestDto request = new InfisicalEnvironmentUpdateRequestDto { Name = name, Slug = slug, Position = position };
+            string body = _serializer.Serialize(request);
+
+            try
+            {
+                _logger.Information(Component, string.Concat("Attempting to update Infisical environment '", environmentId, "'. Please Wait..."));
+                InfisicalHttpResponse response = _invoker.Invoke(connection, InfisicalEndpointNames.UpdateEnvironment, "UpdateEnvironment", pathParameters, null, body);
+                InfisicalEnvironmentSingleResponseDto dto = _serializer.Deserialize<InfisicalEnvironmentSingleResponseDto>(response.Body);
+                response.Clear();
+
+                InfisicalEnvironment mapped = InfisicalEnvironmentMapper.Map(dto != null ? dto.Environment : null, resolvedProjectId);
+                _logger.Information(Component, "Infisical environment update was successful.");
+                return mapped;
+            }
+            catch (Exception)
+            {
+                _logger.Error(Component, "Infisical environment update failed.");
+                throw;
+            }
+        }
+
+        public void Delete(InfisicalConnection connection, string projectId, string environmentId)
+        {
+            if (connection == null) { throw new ArgumentNullException(nameof(connection)); }
+            string resolvedProjectId = FirstNonEmpty(projectId, connection.ProjectId);
+            if (string.IsNullOrEmpty(resolvedProjectId)) { throw new InfisicalConfigurationException("ProjectId is required."); }
+            if (string.IsNullOrEmpty(environmentId)) { throw new InfisicalConfigurationException("EnvironmentId is required."); }
+
+            Dictionary<string, string> pathParameters = new Dictionary<string, string> { { "projectId", resolvedProjectId }, { "environmentId", environmentId } };
+
+            try
+            {
+                _logger.Information(Component, string.Concat("Attempting to delete Infisical environment '", environmentId, "'. Please Wait..."));
+                InfisicalHttpResponse response = _invoker.Invoke(connection, InfisicalEndpointNames.DeleteEnvironment, "DeleteEnvironment", pathParameters, null, null);
+                response.Clear();
+                _logger.Information(Component, "Infisical environment deletion was successful.");
+            }
+            catch (Exception)
+            {
+                _logger.Error(Component, "Infisical environment deletion failed.");
+                throw;
+            }
+        }
+
+        private static string FirstNonEmpty(params string[] values)
+        {
+            if (values == null) { return null; }
+            foreach (string value in values) { if (!string.IsNullOrEmpty(value)) { return value; } }
+            return null;
+        }
+    }
+}

src/PSInfisicalAPI/Environments/InfisicalEnvironmentDtos.cs

@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace PSInfisicalAPI.Environments
+{
+    internal sealed class InfisicalEnvironmentResponseDto
+    {
+        [JsonProperty("id")] public string Id { get; set; }
+        [JsonProperty("_id")] public string InternalId { get; set; }
+        [JsonProperty("name")] public string Name { get; set; }
+        [JsonProperty("slug")] public string Slug { get; set; }
+        [JsonProperty("position")] public int? Position { get; set; }
+        [JsonProperty("projectId")] public string ProjectId { get; set; }
+        [JsonProperty("workspaceId")] public string WorkspaceId { get; set; }
+    }
+
+    internal sealed class InfisicalEnvironmentSingleResponseDto
+    {
+        [JsonProperty("environment")] public InfisicalEnvironmentResponseDto Environment { get; set; }
+    }
+
+    internal sealed class InfisicalEnvironmentWorkspaceWrapperDto
+    {
+        [JsonProperty("workspace")] public InfisicalEnvironmentWorkspaceDto Workspace { get; set; }
+        [JsonProperty("project")] public InfisicalEnvironmentWorkspaceDto Project { get; set; }
+    }
+
+    internal sealed class InfisicalEnvironmentWorkspaceDto
+    {
+        [JsonProperty("id")] public string Id { get; set; }
+        [JsonProperty("environments")] public List<InfisicalEnvironmentResponseDto> Environments { get; set; }
+    }
+
+    internal sealed class InfisicalEnvironmentCreateRequestDto
+    {
+        [JsonProperty("name")] public string Name { get; set; }
+        [JsonProperty("slug")] public string Slug { get; set; }
+        [JsonProperty("position", NullValueHandling = NullValueHandling.Ignore)] public int? Position { get; set; }
+    }
+
+    internal sealed class InfisicalEnvironmentUpdateRequestDto
+    {
+        [JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)] public string Name { get; set; }
+        [JsonProperty("slug", NullValueHandling = NullValueHandling.Ignore)] public string Slug { get; set; }
+        [JsonProperty("position", NullValueHandling = NullValueHandling.Ignore)] public int? Position { get; set; }
+    }
+}

src/PSInfisicalAPI/Environments/InfisicalEnvironmentMapper.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using PSInfisicalAPI.Models;
+
+namespace PSInfisicalAPI.Environments
+{
+    internal static class InfisicalEnvironmentMapper
+    {
+        public static InfisicalEnvironment Map(InfisicalEnvironmentResponseDto dto, string fallbackProjectId)
+        {
+            if (dto == null)
+            {
+                return null;
+            }
+
+            string projectId = !string.IsNullOrEmpty(dto.ProjectId)
+                ? dto.ProjectId
+                : (!string.IsNullOrEmpty(dto.WorkspaceId) ? dto.WorkspaceId : fallbackProjectId);
+
+            return new InfisicalEnvironment
+            {
+                Id = !string.IsNullOrEmpty(dto.Id) ? dto.Id : dto.InternalId,
+                Name = dto.Name,
+                Slug = dto.Slug,
+                Position = dto.Position,
+                ProjectId = projectId
+            };
+        }
+
+        public static InfisicalEnvironment[] MapMany(IEnumerable<InfisicalEnvironmentResponseDto> items, string fallbackProjectId)
+        {
+            if (items == null)
+            {
+                return Array.Empty<InfisicalEnvironment>();
+            }
+
+            List<InfisicalEnvironment> results = new List<InfisicalEnvironment>();
+            foreach (InfisicalEnvironmentResponseDto dto in items)
+            {
+                InfisicalEnvironment mapped = Map(dto, fallbackProjectId);
+                if (mapped != null)
+                {
+                    results.Add(mapped);
+                }
+            }
+
+            return results.ToArray();
+        }
+    }
+}

src/PSInfisicalAPI/Models/InfisicalEnvironment.cs

@@ -0,0 +1,16 @@
+namespace PSInfisicalAPI.Models
+{
+    public sealed class InfisicalEnvironment
+    {
+        public string Id { get; set; }
+        public string Name { get; set; }
+        public string Slug { get; set; }
+        public int? Position { get; set; }
+        public string ProjectId { get; set; }
+
+        public override string ToString()
+        {
+            return string.IsNullOrEmpty(Slug) ? (Name ?? Id) : Slug;
+        }
+    }
+}