docs: Update extension schema reference

docs/reference/schemas/extension/manifest/discover.md

@@ -1,6 +1,6 @@
 ---
 description: JSON schema reference for the 'discover' property in a DSC extension manifest
-ms.date:     02/28/2025
+ms.date:     09/01/2026
 ms.topic:    reference
 title:       DSC extension manifest discover property schema reference
 ---
@@ -15,22 +15,45 @@ Defines how to retrieve DSC resources not available in `PATH` or `DSC_RESOURCE_P
 
 ```yaml
 SchemaDialect: https://json-schema.org/draft/2020-12/schema
-SchemaID:      https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/v3.1.0/extension/manifest.discover.json
+SchemaID:      https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/v3.2.0/extension/manifest.discover.json
 Type:          object
 ```
 
 ## Description
 
-A DSC extension that can enumerate DSC resource not discoverable in the `PATH` or `DSC_RESOURCE_PATH` environment variables
-should define the `export` property in its manifest. This property defines how DSC can get the
-path to otherwise undiscoverable manifests.
+A DSC extension that can enumerate DSC resources not discoverable in the `PATH` or
+`DSC_RESOURCE_PATH` environment variables should define the `discover` property in its manifest.
+This property defines how DSC can get the path to, or the content of, otherwise undiscoverable
+manifests. When the manifest defines this property, the extension has the `discover` capability.
 
-When the DSC performs discovery for any operation, it calls the command defined by this property.
-The extension must return the path to discovered manifests as [JSON lines][05]. Each JSON Line
-should be an object representing the instance and validate against the
-[DSC extension discover operation stdout schema reference][06].
+When DSC performs discovery for any operation, it calls the command defined by this property with
+the folder containing the extension manifest as the working directory. The extension must return
+the discovered manifests as [JSON Lines][01]. Each JSON Line must be an object that validates
+against the [DSC extension discover operation stdout schema reference][02].
 
-## Required Properties
+## Examples
+
+The following example shows the `discover` property from the manifest for the
+`Microsoft.PowerShell/Discover` extension. It runs a PowerShell script and passes the list of
+manifest file extensions that DSC recognizes to the script's `-extensions` parameter as a quoted
+string.
+
+```yaml
+discover:
+  executable: pwsh
+  args:
+    - -NoLogo
+    - -NonInteractive
+    - -ExecutionPolicy
+    - Bypass
+    - -NoProfile
+    - -Command
+    - ./powershell.discover.ps1
+    - extensionsArg:  -extensions
+      includeQuotes: true
+```
+
+## Required properties
 
 The `discover` definition must include these properties:
 
@@ -52,18 +75,15 @@ Required: true
 
 ### args
 
-The `args` property defines the list of arguments to pass to the command. The arguments can be any
-number of strings. If you want to pass the JSON object representing the property bag for the
-extension input to an argument, you can define a single item in the array as a
-[JSON object](#json-input-argument), indicating the name of the argument with the `jsonInputArg`
-string property and whether the argument is mandatory for the command with the `mandatory` boolean
-property.
+The `args` property defines the list of arguments to pass to the command. Each item in the array
+can be a string representing a static argument or an
+[extensions argument](#extensions-argument) object that receives the list of file extensions DSC
+recognizes for manifests.
 
 ```yaml
-Type:     array
-Required: false
-Default:  []
-Type:     [string, object(JSON Input Argument)]
+Type:      array
+Required:  false
+ItemsType: [string, object(Extensions argument)]
 ```
 
 #### String arguments
@@ -75,23 +95,37 @@ command, like `discover` or `--format`.
 Type: string
 ```
 
-#### JSON input argument
+#### Extensions argument
+
+Defines an argument that receives the list of file extensions DSC recognizes for manifests. Use
+this argument so the extension can find manifests by file name without hard-coding the naming
+conventions. This argument type was added in DSC version 3.3.0.
+
+DSC passes the value of `extensionsArg` to the command, followed by a single argument containing
+the comma-separated list of recognized file extensions:
+
+- `.dsc.adaptedresource.json`, `.dsc.adaptedresource.yaml`, and `.dsc.adaptedresource.yml`
+- `.dsc.extension.json`, `.dsc.extension.yaml`, and `.dsc.extension.yml`
+- `.dsc.manifests.json`, `.dsc.manifests.yaml`, and `.dsc.manifests.yml`
+- `.dsc.resource.json`, `.dsc.resource.yaml`, and `.dsc.resource.yml`
 
-Defines an argument for the command that accepts the JSON input object as a string. DSC passes the
-JSON input to the named argument when available. A JSON input argument is defined as a JSON object
-with the following properties:
+An extensions argument is defined as a JSON object with the following properties:
 
-- `jsonInputArg` (required) - the argument to pass the JSON data to for the command, like `--input`.
-- `mandatory` (optional) - Indicate whether DSC should always pass the argument to the command,
-  even when there's no JSON input for the command. In that case, DSC passes an empty string to the
-  JSON input argument.
+- `extensionsArg` (required) - The argument to pass before the list of file extensions, like
+  `--extensions`.
+- `includeQuotes` (optional) - Indicates whether DSC should wrap the list of file extensions in
+  double quotes. The default is `false`.
 
-You can only define one JSON input argument per arguments array.
+> [!NOTE]
+> In DSC 3.2.x, the `args` array for the `discover` property accepted the same JSON input argument
+> object (`jsonInputArg`) as the `get.args` property in resource manifests. Starting with DSC
+> 3.3.0, that form isn't valid for the `discover` property.
 
 ```yaml
-Type:                object
-RequiredProperties: [jsonInputArg]
+Type:               object
+RequiredProperties: [extensionsArg]
 ```
 
-[05]: https://jsonlines.org/
-[06]: ../stdout/discover.md
+<!-- Link reference definitions -->
+[01]: https://jsonlines.org/
+[02]: ../stdout/discover.md

docs/reference/schemas/extension/manifest/import.md

@@ -0,0 +1,117 @@
+---
+description: JSON schema reference for the 'import' property in a DSC extension manifest
+ms.date:     09/01/2026
+ms.topic:    reference
+title:       DSC extension manifest import property schema reference
+---
+
+# DSC extension manifest import property schema reference
+
+## Synopsis
+
+Defines how to call the extension to convert a file that DSC can't parse directly into a
+configuration document.
+
+## Metadata
+
+```yaml
+SchemaDialect: https://json-schema.org/draft/2020-12/schema
+SchemaID:      https://raw.githubusercontent.com/PowerShell/DSC/main/schemas/v3.2.0/extension/manifest.import.json
+Type:          object
+```
+
+## Description
+
+The `import` property of an extension manifest defines how to call the extension to convert a file
+that DSC can't parse directly into a configuration document. When this property is defined, the
+extension has the `import` capability.
+
+When you pass a file to a `dsc config` command with the `--file` option, DSC checks whether any
+extension with the `import` capability handles the file's extension. DSC uses the content returned
+by the first extension that successfully imports the file as the configuration document. If no
+extension imports the file, DSC reads the file directly.
+
+The extension must return the imported file as a [JSON Line][01]. The JSON Line must be an object
+that validates against the [DSC extension import operation stdout schema reference][02].
+
+## Required properties
+
+The `import` definition must include these properties:
+
+- [fileExtensions](#fileextensions)
+- [executable](#executable)
+
+## Properties
+
+### fileExtensions
+
+The `fileExtensions` property defines the list of file extensions that the extension can import as
+a configuration document, like `["bicep"]` to import `.bicep` files.
+
+The value for this property must be an array. Every item in the array must be a file extension
+_without_ a leading period. If this array is empty, DSC writes a warning during discovery and the
+extension can't import any files.
+
+### executable
+
+The `executable` property defines the name of the command to run. The value must be the name of a
+command discoverable in the system's `PATH` environment variable or the full path to the command. A
+file extension is only required when the command isn't recognizable by the operating system as an
+executable.
+
+```yaml
+Type:     string
+Required: true
+```
+
+### args
+
+The `args` property defines the list of arguments to pass to the command. Each item in the array
+can be a string representing a static argument or an [file argument](#file-argument) object that
+receives the absolute path to the file the extension should import.
+
+```yaml
+Type:      array
+Required:  false
+ItemsType: [string, object(Extensions argument)]
+```
+
+#### String arguments
+
+Any item in the argument array can be a string representing a static argument to pass to the
+command, like `import` or `--format`.
+
+```yaml
+Type: string
+```
+
+#### File argument
+
+Defines an argument that receives the path to the file to import.
+
+DSC passes the value of `fileArg` followed by the absolute path to the file to import. If `fileArg`
+is an empty string, DSC passes only the path.
+
+A file argument is defined as a JSON object with the following properties:
+
+- `fileArg` (required) - The argument to pass before the path to the file to import, like `--path`.
+
+```yaml
+Type:               object
+RequiredProperties: [fileArg]
+```
+
+### output
+
+The `output` property defines a DSC configuration expression that DSC evaluates after the command
+completes to transform the command's output into the configuration document. Use the `stdout()`
+function in the expression to access the text the command wrote to stdout. When this property isn't
+defined, DSC uses the command's output as the configuration document without modification.
+
+```yaml
+type: string
+```
+
+<!-- Link reference definitions -->
+[01]: https://jsonlines.org/
+[02]: ../stdout/import.md