codify-plugin-lib 1.0.182-beta44 → 1.0.182-beta46

package/dist/index.d.ts

@@ -14,4 +14,5 @@ export * from './utils/file-utils.js';
 export * from './utils/functions.js';
 export * from './utils/index.js';
 export * from './utils/verbosity-level.js';
+export * from 'zod/v4';
 export declare function runPlugin(plugin: Plugin): Promise<void>;

package/dist/index.js

@@ -14,6 +14,7 @@ export * from './utils/file-utils.js';
 export * from './utils/functions.js';
 export * from './utils/index.js';
 export * from './utils/verbosity-level.js';
+export * from 'zod/v4';
 export async function runPlugin(plugin) {
     const messageHandler = new MessageHandler(plugin);
     process.on('message', (message) => messageHandler.onMessage(message));

package/dist/plugin/plugin.js

@@ -55,7 +55,7 @@ export class Plugin {
             throw new Error(`Cannot get info for resource ${data.type}, resource doesn't exist`);
         }
         const resource = this.resourceControllers.get(data.type);
-        const schema = resource.settings.schema;
+        const schema = resource.parsedSettings.schema;
         const requiredPropertyNames = (resource.settings.importAndDestroy?.requiredParameters
             ?? (typeof resource.settings.allowMultiple === 'object' ? resource.settings.allowMultiple.identifyingParameters : null)
             ?? schema?.required

package/dist/resource/parsed-resource-settings.d.ts

@@ -18,10 +18,12 @@ export type ParsedParameterSetting = {
 export declare class ParsedResourceSettings<T extends StringIndexedObject> implements ResourceSettings<T> {
     private cache;
     id: string;
+    description?: string;
     schema?: Partial<JSONSchemaType<T | any>>;
     allowMultiple?: {
+        identifyingParameters?: string[];
         matcher?: (desired: Partial<T>, current: Partial<T>) => boolean;
-        requiredParameters?: string[];
+        findAllParameters?: () => Promise<Array<Partial<T>>>;
     } | boolean;
     removeStatefulParametersBeforeDestroy?: boolean | undefined;
     dependencies?: string[] | undefined;

package/dist/resource/parsed-resource-settings.js

@@ -1,8 +1,10 @@
+import { ZodObject, z } from 'zod';
 import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
 import { resolveElementEqualsFn, resolveEqualsFn, resolveMatcher, resolveParameterTransformFn } from './resource-settings.js';
 export class ParsedResourceSettings {
     cache = new Map();
     id;
+    description;
     schema;
     allowMultiple;
     removeStatefulParametersBeforeDestroy;
@@ -13,8 +15,19 @@ export class ParsedResourceSettings {
     settings;
     constructor(settings) {
         this.settings = settings;
-        const { parameterSettings, ...rest } = settings;
+        const { parameterSettings, schema, ...rest } = settings;
         Object.assign(this, rest);
+        if (schema) {
+            this.schema = schema instanceof ZodObject
+                ? z.toJSONSchema(schema.strict(), {
+                    target: 'draft-7',
+                    override(ctx) {
+                        ctx.jsonSchema.title = settings.id;
+                        ctx.jsonSchema.description = settings.description ?? `${settings.id} resource. Can be used to manage ${settings.id}`;
+                    }
+                })
+                : schema;
+        }
         this.validateSettings();
     }
     get typeId() {
@@ -118,7 +131,7 @@ export class ParsedResourceSettings {
             && typeof this.settings.allowMultiple === 'object' && this.settings.allowMultiple?.identifyingParameters?.includes(k))) {
             throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed to be identifying parameters for allowMultiple.`);
         }
-        const schema = this.settings.schema;
+        const schema = this.schema;
         if (!this.settings.importAndDestroy && (schema?.oneOf
             && Array.isArray(schema.oneOf)
             && schema.oneOf.some((s) => s.required))

package/dist/resource/resource-controller.js

@@ -17,16 +17,16 @@ export class ResourceController {
         this.settings = resource.getSettings();
         this.typeId = this.settings.id;
         this.dependencies = this.settings.dependencies ?? [];
-        if (this.settings.schema) {
+        this.parsedSettings = new ParsedResourceSettings(this.settings);
+        if (this.parsedSettings.schema) {
             this.ajv = new Ajv({
                 allErrors: true,
                 strict: true,
                 strictRequired: false,
                 allowUnionTypes: true
             });
-            this.schemaValidator = this.ajv.compile(this.settings.schema);
+            this.schemaValidator = this.ajv.compile(this.parsedSettings.schema);
         }
-        this.parsedSettings = new ParsedResourceSettings(this.settings);
     }
     async initialize() {
         return this.resource.initialize();
@@ -374,8 +374,8 @@ ${JSON.stringify(refresh, null, 2)}
             .sort((a, b) => this.parsedSettings.statefulParameterOrder.get(a.name) - this.parsedSettings.statefulParameterOrder.get(b.name));
     }
     getAllParameterKeys() {
-        return this.settings.schema
-            ? Object.keys(this.settings.schema?.properties)
+        return this.parsedSettings.schema
+            ? Object.keys(this.parsedSettings.schema?.properties)
             : Object.keys(this.parsedSettings.parameterSettings);
     }
     getParametersToRefreshForImport(parameters, context) {

package/dist/resource/resource-settings.d.ts

@@ -1,6 +1,8 @@
 import { JSONSchemaType } from 'ajv';
 import { OS, StringIndexedObject } from 'codify-schemas';
+import { ZodObject } from 'zod';
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
+import { ParsedResourceSettings } from './parsed-resource-settings.js';
 import { RefreshContext } from './resource.js';
 export interface InputTransformation {
     to: (input: any) => Promise<any> | any;
@@ -21,12 +23,16 @@ export interface ResourceSettings<T extends StringIndexedObject> {
     /**
      * Schema to validate user configs with. Must be in the format JSON Schema draft07
      */
-    schema?: Partial<JSONSchemaType<T | any>>;
+    schema?: Partial<JSONSchemaType<T | any>> | ZodObject;
     /**
      * Mark the resource as sensitive. Defaults to false. This prevents the resource from automatically being imported by init and import.
      * This differs from the parameter level sensitivity which also prevents the parameter value from being displayed in the plan.
      */
     isSensitive?: boolean;
+    /**
+     * An optional description of the resource. This does not affect the behavior of the resource.
+     */
+    description?: string;
     /**
      * Allow multiple of the same resource to unique. Set truthy if
      * multiples are allowed, for example for applications, there can be multiple copy of the same application installed
@@ -290,4 +296,4 @@ export declare function resolveEqualsFn(parameter: ParameterSetting): (desired:
 export declare function resolveElementEqualsFn(parameter: ArrayParameterSetting): (desired: unknown, current: unknown) => boolean;
 export declare function resolveFnFromEqualsFnOrString(fnOrString: ((a: unknown, b: unknown) => boolean) | ParameterSettingType | undefined): ((a: unknown, b: unknown) => boolean) | undefined;
 export declare function resolveParameterTransformFn(parameter: ParameterSetting): InputTransformation | undefined;
-export declare function resolveMatcher<T extends StringIndexedObject>(settings: ResourceSettings<T>): (desired: Partial<T>, current: Partial<T>) => boolean;
+export declare function resolveMatcher<T extends StringIndexedObject>(settings: ParsedResourceSettings<T>): (desired: Partial<T>, current: Partial<T>) => boolean;

package/dist/resource/resource-settings.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { addVariablesToPath, areArraysEqual, resolvePathWithVariables, tildify, untildify } from '../utils/functions.js';
 const ParameterEqualsDefaults = {
     'boolean': (a, b) => Boolean(a) === Boolean(b),
-    'directory': (a, b) => {
+    'directory'(a, b) {
         let transformedA = resolvePathWithVariables(untildify(String(a)));
         let transformedB = resolvePathWithVariables(untildify(String(b)));
         if (transformedA.startsWith('.')) { // Only relative paths start with '.'
@@ -65,7 +65,7 @@ export function resolveFnFromEqualsFnOrString(fnOrString) {
 const ParameterTransformationDefaults = {
     'directory': {
         to: (a) => resolvePathWithVariables((untildify(String(a)))),
-        from: (a, original) => {
+        from(a, original) {
             if (ParameterEqualsDefaults.directory(a, original)) {
                 return original;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codify-plugin-lib",
-  "version": "1.0.182-beta44",
+  "version": "1.0.182-beta46",
   "description": "Library plugin library",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -26,7 +26,8 @@
     "lodash.isequal": "^4.5.0",
     "nanoid": "^5.0.9",
     "strip-ansi": "^7.1.0",
-    "uuid": "^10.0.0"
+    "uuid": "^10.0.0",
+    "zod": "4.1.13"
   },
   "devDependencies": {
     "@apidevtools/json-schema-ref-parser": "^11.7.2",

package/src/index.ts

@@ -16,6 +16,7 @@ export * from './utils/file-utils.js'
 export * from './utils/functions.js'
 export * from './utils/index.js'
 export * from './utils/verbosity-level.js'
+export * from 'zod/v4';
 
 export async function runPlugin(plugin: Plugin) {
   const messageHandler = new MessageHandler(plugin);

package/src/plugin/plugin.test.ts

@@ -7,6 +7,7 @@ import { spy } from 'sinon';
 import { ResourceSettings } from '../resource/resource-settings.js';
 import { TestConfig, TestStatefulParameter } from '../utils/test-utils.test.js';
 import { getPty } from '../pty/index.js';
+import { z } from 'zod';
 
 interface TestConfig extends StringIndexedObject {
   propA: string;
@@ -170,6 +171,36 @@ describe('Plugin tests', () => {
     })
   })
 
+  it('Can get resource info (zod schema)', async () => {
+    const schema = z
+      .object({
+        plugins: z
+          .array(z.string())
+          .describe(
+            'Asdf plugins to install. See: https://github.com/asdf-community for a full list'
+          )
+      })
+      .strict()
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'typeId',
+          operatingSystems: [OS.Darwin],
+          schema,
+        }
+      }
+    }
+    const testPlugin = Plugin.create('testPlugin', [resource as any])
+
+    const resourceInfo = await testPlugin.getResourceInfo({ type: 'typeId' })
+    expect(resourceInfo.import).toMatchObject({
+      requiredParameters: [
+        'plugins'
+      ]
+    })
+  })
+
   it('Get resource info to default import to the one specified in the resource settings', async () => {
     const schema = {
       '$schema': 'http://json-schema.org/draft-07/schema',

package/src/plugin/plugin.ts

@@ -89,7 +89,7 @@ export class Plugin {
 
     const resource = this.resourceControllers.get(data.type)!;
 
-    const schema = resource.settings.schema as JSONSchemaType<any> | undefined;
+    const schema = resource.parsedSettings.schema as JSONSchemaType<any> | undefined;
     const requiredPropertyNames = (
       resource.settings.importAndDestroy?.requiredParameters
       ?? (typeof resource.settings.allowMultiple === 'object' ? resource.settings.allowMultiple.identifyingParameters : null)

package/src/resource/parsed-resource-settings.test.ts

@@ -2,6 +2,8 @@ import { describe, expect, it } from 'vitest';
 import { ResourceSettings } from './resource-settings.js';
 import { ParsedResourceSettings } from './parsed-resource-settings.js';
 import { TestConfig } from '../utils/test-utils.test.js';
+import { z } from 'zod';
+import { OS } from 'codify-schemas';
 
 describe('Resource options parser tests', () => {
   it('Parses default values from options', () => {
@@ -159,4 +161,26 @@ describe('Resource options parser tests', () => {
 
     expect(() => new ParsedResourceSettings(option)).toThrowError()
   })
+
+  it('Can handle a zod schema', () => {
+
+    const schema = z.object({
+      propA: z.string(),
+      repository: z.string(),
+    })
+
+    const option: ResourceSettings<z.infer<typeof schema>> = {
+      id: 'typeId',
+      operatingSystems: [OS.Darwin],
+      schema,
+      importAndDestroy: {
+        defaultRefreshValues: {
+          repository: 'abc'
+        }
+      }
+    }
+
+    console.log(new ParsedResourceSettings(option))
+
+  })
 })

package/src/resource/parsed-resource-settings.ts

@@ -1,5 +1,6 @@
 import { JSONSchemaType } from 'ajv';
 import { OS, StringIndexedObject } from 'codify-schemas';
+import { ZodObject, z } from 'zod';
 
 import { StatefulParameterController } from '../stateful-parameter/stateful-parameter-controller.js';
 import {
@@ -7,12 +8,12 @@ import {
   DefaultParameterSetting,
   InputTransformation,
   ParameterSetting,
+  ResourceSettings,
+  StatefulParameterSetting,
   resolveElementEqualsFn,
   resolveEqualsFn,
   resolveMatcher,
-  resolveParameterTransformFn,
-  ResourceSettings,
-  StatefulParameterSetting
+  resolveParameterTransformFn
 } from './resource-settings.js';
 
 export interface ParsedStatefulParameterSetting extends DefaultParameterSetting {
@@ -29,7 +30,7 @@ export type ParsedArrayParameterSetting = {
 
 export type ParsedParameterSetting =
   {
-  isEqual: (desired: unknown, current: unknown) => boolean;
+    isEqual: (desired: unknown, current: unknown) => boolean;
   } & (DefaultParameterSetting
   | ParsedArrayParameterSetting
   | ParsedStatefulParameterSetting)
@@ -37,10 +38,13 @@ export type ParsedParameterSetting =
 export class ParsedResourceSettings<T extends StringIndexedObject> implements ResourceSettings<T> {
   private cache = new Map<string, unknown>();
   id!: string;
+  description?: string;
+
   schema?: Partial<JSONSchemaType<T | any>>;
   allowMultiple?: {
+    identifyingParameters?: string[];
     matcher?: (desired: Partial<T>, current: Partial<T>) => boolean;
-    requiredParameters?: string[]
+    findAllParameters?: () => Promise<Array<Partial<T>>>
   } | boolean;
 
   removeStatefulParametersBeforeDestroy?: boolean | undefined;
@@ -54,10 +58,22 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
 
   constructor(settings: ResourceSettings<T>) {
     this.settings = settings;
+    const { parameterSettings, schema, ...rest } = settings;
 
-    const { parameterSettings, ...rest } = settings;
     Object.assign(this, rest);
 
+    if (schema) {
+      this.schema = schema instanceof ZodObject
+        ? z.toJSONSchema(schema.strict(), {
+          target: 'draft-7',
+          override(ctx) {
+            ctx.jsonSchema.title = settings.id;
+            ctx.jsonSchema.description = settings.description ?? `${settings.id} resource. Can be used to manage ${settings.id}`;
+          }
+        }) as JSONSchemaType<T>
+        : schema;
+    }
+
     this.validateSettings();
   }
 
@@ -199,7 +215,7 @@ export class ParsedResourceSettings<T extends StringIndexedObject> implements Re
       throw new Error(`Resource: ${this.id}. Stateful parameters are not allowed to be identifying parameters for allowMultiple.`)
     }
 
-    const schema = this.settings.schema as JSONSchemaType<any>;
+    const schema = this.schema as JSONSchemaType<any>;
     if (!this.settings.importAndDestroy && (schema?.oneOf
         && Array.isArray(schema.oneOf)
         && schema.oneOf.some((s) => s.required)

package/src/resource/resource-controller.test.ts

@@ -11,6 +11,7 @@ import { tildify, untildify } from '../utils/functions.js';
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
 import { Plan } from '../plan/plan.js';
 import os from 'node:os';
+import { z } from 'zod';
 
 describe('Resource tests', () => {
 
@@ -952,4 +953,129 @@ describe('Resource tests', () => {
 
     process.env = oldProcessEnv;
   })
+
+  it('Can import and return all of the imported parameters (zod schema)', async () => {
+    const schema = z.object({
+      path: z
+        .string()
+        .describe(
+          'A list of paths to add to the PATH environment variable'
+        ),
+      paths: z
+        .array(z.string())
+        .describe(
+          'A list of paths to add to the PATH environment variable'
+        ),
+      prepend: z
+        .boolean()
+        .describe(
+          'Whether to prepend the paths to the PATH environment variable'
+        ),
+      declarationsOnly: z
+        .boolean()
+        .describe(
+          'Whether to only declare the paths in the PATH environment variable'
+        ),
+    })
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'path',
+          schema,
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            path: { type: 'directory' },
+            paths: { canModify: true, type: 'array', itemType: 'directory' },
+            prepend: { default: false, setting: true },
+            declarationsOnly: { default: false, setting: true },
+          },
+          importAndDestroy: {
+            refreshMapper: (input, context) => {
+              if (Object.keys(input).length === 0) {
+                return { paths: [], declarationsOnly: true };
+              }
+
+              return input;
+            }
+          },
+          allowMultiple: {
+            matcher: (desired, current) => {
+              if (desired.path) {
+                return desired.path === current.path;
+              }
+
+              const currentPaths = new Set(current.paths)
+              return desired.paths?.some((p) => currentPaths.has(p));
+            }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {
+          paths: [
+            `${os.homedir()}/.pyenv/bin`,
+            `${os.homedir()}/.bun/bin`,
+            `${os.homedir()}/.deno/bin`,
+            `${os.homedir()}/.jenv/bin`,
+            `${os.homedir()}/a/random/path`,
+            `${os.homedir()}/.nvm/.bin/2`,
+            `${os.homedir()}/.nvm/.bin/3`
+          ]
+        }
+      }
+    }
+
+    const oldProcessEnv = structuredClone(process.env);
+
+    process.env['PYENV_ROOT'] = `${os.homedir()}/.pyenv`
+    process.env['BUN_INSTALL'] = `${os.homedir()}/.bun`
+    process.env['DENO_INSTALL'] = `${os.homedir()}/.deno`
+    process.env['JENV'] = `${os.homedir()}/.jenv`
+    process.env['NVM_DIR'] = `${os.homedir()}/.nvm`
+
+    const controller = new ResourceController(resource);
+    const importResult1 = await controller.import({ type: 'path' }, {});
+    expect(importResult1).toMatchObject([
+      {
+        'core': {
+          'type': 'path'
+        },
+        'parameters': {
+          'paths': [
+            '$PYENV_ROOT/bin',
+            '$BUN_INSTALL/bin',
+            '$DENO_INSTALL/bin',
+            '$JENV/bin',
+            '~/a/random/path',
+            '$NVM_DIR/.bin/2',
+            '$NVM_DIR/.bin/3'
+          ]
+        }
+      }
+    ])
+
+    const importResult2 = await controller.import({ type: 'path' }, { paths: ['$PYENV_ROOT/bin', '$BUN_INSTALL/bin'] });
+    expect(importResult2).toMatchObject([
+      {
+        'core': {
+          'type': 'path'
+        },
+        'parameters': {
+          'paths': [
+            '$PYENV_ROOT/bin',
+            '$BUN_INSTALL/bin',
+            '$DENO_INSTALL/bin',
+            '$JENV/bin',
+            '~/a/random/path',
+            '$NVM_DIR/.bin/2',
+            '$NVM_DIR/.bin/3'
+          ]
+        }
+      }
+    ])
+
+    process.env = oldProcessEnv;
+  })
 });

package/src/resource/resource-controller.ts

@@ -36,18 +36,17 @@ export class ResourceController<T extends StringIndexedObject> {
 
     this.typeId = this.settings.id;
     this.dependencies = this.settings.dependencies ?? [];
+    this.parsedSettings = new ParsedResourceSettings<T>(this.settings);
 
-    if (this.settings.schema) {
+    if (this.parsedSettings.schema) {
       this.ajv = new Ajv({
         allErrors: true,
         strict: true,
         strictRequired: false,
         allowUnionTypes: true
       })
-      this.schemaValidator = this.ajv.compile(this.settings.schema);
+      this.schemaValidator = this.ajv.compile(this.parsedSettings.schema);
     }
-
-    this.parsedSettings = new ParsedResourceSettings<T>(this.settings);
   }
 
   async initialize(): Promise<void> {
@@ -526,8 +525,8 @@ ${JSON.stringify(refresh, null, 2)}
   }
 
   private getAllParameterKeys(): string[] {
-    return this.settings.schema
-      ? Object.keys((this.settings.schema as any)?.properties)
+    return this.parsedSettings.schema
+      ? Object.keys((this.parsedSettings.schema as any)?.properties)
       : Object.keys(this.parsedSettings.parameterSettings);
   }
 

package/src/resource/resource-settings.test.ts

@@ -13,6 +13,7 @@ import { ArrayParameterSetting, ParameterSetting, ResourceSettings } from './res
 import { ResourceController } from './resource-controller.js';
 import os from 'node:os';
 import path from 'node:path';
+import { z } from 'zod';
 
 describe('Resource parameter tests', () => {
   it('Generates a resource plan that includes stateful parameters (create)', async () => {
@@ -1174,4 +1175,39 @@ describe('Resource parameter tests', () => {
     expect(from2).to.eq('$HOME/abc/def')
 
   })
+
+  it('Can match directories 2', async () => {
+
+    const schema = z.object({
+      propA: z.string(),
+      propB: z.number(),
+    });
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<z.infer<typeof schema>> {
+        return {
+          id: 'resourceType',
+          schema,
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            propA: { type: 'directory' }
+          },
+        }
+      }
+    };
+
+    const controller = new ResourceController(resource);
+    const transformations = controller.parsedSettings.inputTransformations.propA;
+
+    const to = transformations!.to('$HOME/abc/def')
+    expect(to).to.eq(os.homedir() + '/abc/def')
+
+    const from = transformations!.from(os.homedir() + '/abc/def')
+    expect(from).to.eq('~/abc/def')
+
+    const from2 = transformations!.from(os.homedir() + '/abc/def', '$HOME/abc/def')
+    expect(from2).to.eq('$HOME/abc/def')
+
+  })
+
 })

package/src/resource/resource-settings.ts

@@ -2,6 +2,7 @@ import { JSONSchemaType } from 'ajv';
 import { OS, StringIndexedObject } from 'codify-schemas';
 import isObjectsEqual from 'lodash.isequal'
 import path from 'node:path';
+import { ZodObject } from 'zod';
 
 import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
 import {
@@ -11,6 +12,7 @@ import {
   tildify,
   untildify
 } from '../utils/functions.js';
+import { ParsedResourceSettings } from './parsed-resource-settings.js';
 import { RefreshContext } from './resource.js';
 
 export interface InputTransformation {
@@ -36,7 +38,7 @@ export interface ResourceSettings<T extends StringIndexedObject> {
   /**
    * Schema to validate user configs with. Must be in the format JSON Schema draft07
    */
-  schema?: Partial<JSONSchemaType<T | any>>;
+  schema?: Partial<JSONSchemaType<T | any>> | ZodObject;
 
   /**
    * Mark the resource as sensitive. Defaults to false. This prevents the resource from automatically being imported by init and import.
@@ -44,6 +46,11 @@ export interface ResourceSettings<T extends StringIndexedObject> {
    */
   isSensitive?: boolean;
 
+  /**
+   * An optional description of the resource. This does not affect the behavior of the resource.
+   */
+  description?: string;
+
   /**
    * Allow multiple of the same resource to unique. Set truthy if
    * multiples are allowed, for example for applications, there can be multiple copy of the same application installed
@@ -349,7 +356,7 @@ export interface StatefulParameterSetting extends DefaultParameterSetting {
 
 const ParameterEqualsDefaults: Partial<Record<ParameterSettingType, (a: unknown, b: unknown) => boolean>> = {
   'boolean': (a: unknown, b: unknown) => Boolean(a) === Boolean(b),
-  'directory': (a: unknown, b: unknown) => {
+  'directory'(a: unknown, b: unknown) {
     let transformedA = resolvePathWithVariables(untildify(String(a)))
     let transformedB = resolvePathWithVariables(untildify(String(b)))
 
@@ -430,7 +437,7 @@ export function resolveFnFromEqualsFnOrString(
 const ParameterTransformationDefaults: Partial<Record<ParameterSettingType, InputTransformation>> = {
   'directory': {
     to: (a: unknown) => resolvePathWithVariables((untildify(String(a)))),
-    from: (a: unknown, original) => {
+    from(a: unknown, original) {
       if (ParameterEqualsDefaults.directory!(a, original)) {
         return original;
       }
@@ -489,7 +496,7 @@ export function resolveParameterTransformFn(
 }
 
 export function resolveMatcher<T extends StringIndexedObject>(
-  settings: ResourceSettings<T>
+  settings: ParsedResourceSettings<T>
 ): (desired: Partial<T>, current: Partial<T>) => boolean {
   return typeof settings.allowMultiple === 'boolean' || !settings.allowMultiple?.matcher
     ? ((desired: Partial<T>, current: Partial<T>) => {