codify-plugin-lib 1.0.76 → 1.0.77

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

@@ -0,0 +1,149 @@
+import { StringIndexedObject } from 'codify-schemas';
+import { StatefulParameter } from './stateful-parameter.js';
+/**
+ * The configuration and settings for a resource.
+ */
+export interface ResourceSettings<T extends StringIndexedObject> {
+    /**
+     * The typeId of the resource.
+     */
+    id: string;
+    /**
+     * Schema to validate user configs with. Must be in the format JSON Schema draft07
+     */
+    schema?: unknown;
+    /**
+     * 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
+     * on the system. Or there can be multiple git repos. Defaults to false.
+     */
+    allowMultiple?: {
+        /**
+         * If multiple copies are allowed then a matcher must be defined to match the desired
+         * config with one of the resources currently existing on the system. Return null if there is no match.
+         *
+         * @param current An array of resources found installed on the system
+         * @param desired The desired config to match.
+         *
+         * @return The matched resource.
+         */
+        matcher: (desired: Partial<T>, current: Partial<T>[]) => Partial<T>;
+    };
+    /**
+     * If true, {@link StatefulParameter} remove() will be called before resource destruction. This is useful
+     * if the stateful parameter needs to be first uninstalled (cleanup) before the overall resource can be
+     * uninstalled. Defaults to false.
+     */
+    removeStatefulParametersBeforeDestroy?: boolean;
+    /**
+     * An array of type ids of resources that this resource depends on. This affects the order in which multiple resources are
+     * planned and applied.
+     */
+    dependencies?: string[];
+    /**
+     * Options for configuring parameters operations including overriding the equals function, adding default values
+     * and applying any input transformations. Use parameter settings to define stateful parameters as well.
+     */
+    parameterSettings?: Partial<Record<keyof T, ParameterSetting>>;
+    /**
+     * A config level transformation that is only applied to the user supplied desired config. This transformation is allowed
+     * to add, remove or modify keys as well as values. Changing this transformation for existing libraries will mess up existing states.
+     *
+     * @param desired
+     */
+    inputTransformation?: (desired: Partial<T>) => Promise<unknown> | unknown;
+}
+/**
+ * The type of parameter. This value is mainly used to determine a pre-set equality method for comparing the current
+ * config with desired config. Certain types will have additional options to help support it. For example the type
+ * stateful requires a stateful parameter definition and type array takes an isElementEqual method.
+ */
+export type ParameterSettingType = 'any' | 'array' | 'boolean' | 'directory' | 'number' | 'stateful' | 'string' | 'version';
+/**
+ * Typing information for the parameter setting. This represents a setting on a specific parameter within a
+ * resource. Options for configuring parameters operations including overriding the equals function, adding default values
+ * and applying any input transformations. See {@link DefaultParameterSetting } for more information.
+ * Use parameter settings to define stateful parameters as well.
+ */
+export type ParameterSetting = ArrayParameterSetting | DefaultParameterSetting | StatefulParameterSetting;
+/**
+ * The parent class for parameter settings. The options are applicable to array parameter settings
+ * as well.
+ */
+export interface DefaultParameterSetting {
+    /**
+     * The type of the value of this parameter. See {@link ParameterSettingType} for the available options. This value
+     * is mainly used to determine the equality method when performing diffing.
+     */
+    type?: ParameterSettingType;
+    /**
+     * Default value for the parameter. If a value is not provided in the config, then this value will be used.
+     */
+    default?: unknown;
+    /**
+     * A transformation of the input value for this parameter. This transformation is only applied to the desired parameter
+     * value supplied by the user.
+     *
+     * @param input The original parameter value from the desired config.
+     */
+    inputTransformation?: (input: any) => Promise<any> | unknown;
+    /**
+     * Customize the equality comparison for a parameter. This is used in the diffing algorithm for generating the plan.
+     * This value will override the pre-set equality function from the type. Return true if the desired value is
+     * equivalent to the current value.
+     *
+     * @param desired The desired value.
+     * @param current The current value.
+     *
+     * @return Return true if equal
+     */
+    isEqual?: (desired: any, current: any) => boolean;
+    /**
+     * Chose if the resource can be modified instead of re-created when there is a change to this parameter.
+     * Defaults to false (re-create).
+     *
+     * Examples:
+     * 1. Settings like git user name and git user email that have setter calls and don't require the re-installation of git
+     * 2. AWS profile secret keys that can be updated without the re-installation of AWS CLI
+     */
+    canModify?: boolean;
+}
+/**
+ * Array type specific settings. See {@link DefaultParameterSetting } for a full list of options.
+ */
+export interface ArrayParameterSetting extends DefaultParameterSetting {
+    type: 'array';
+    /**
+     * An element level equality function for arrays. The diffing algorithm will take isElementEqual and use it in a
+     * O(n^2) equality comparison to determine if the overall array is equal. This value will override the pre-set equality
+     * function for arrays (desired === current). Return true if the desired element is equivalent to the current element.
+     *
+     * @param desired An element of the desired array
+     * @param current An element of the current array
+     *
+     * @return Return true if desired is equivalent to current.
+     */
+    isElementEqual?: (desired: any, current: any) => boolean;
+}
+/**
+ * Stateful parameter type specific settings. A stateful parameter is a sub-resource that can hold its own
+ * state but is still tied to the overall state of the resource. For example 'homebrew' is represented
+ * as a resource and taps, formulas and casks are represented as a stateful parameter. A formula can be installed,
+ * modified and removed (has state) but it is still tied to the overall lifecycle of homebrew.
+ *
+ */
+export interface StatefulParameterSetting extends DefaultParameterSetting {
+    type: 'stateful';
+    /**
+     * The stateful parameter definition. A stateful parameter is a sub-resource that can hold its own
+     * state but is still tied to the overall state of the resource. For example 'homebrew' is represented
+     * as a resource and taps, formulas and casks are represented as a stateful parameter. A formula can be installed,
+     * modified and removed (has state) but it is still tied to the overall lifecycle of homebrew.
+     */
+    definition: StatefulParameter<any, unknown>;
+    /**
+     * The order multiple stateful parameters should be applied in. The order is applied in ascending order (1, 2, 3...).
+     */
+    order?: number;
+}
+export declare const ParameterEqualsDefaults: Partial<Record<ParameterSettingType, (a: unknown, b: unknown) => boolean>>;

package/dist/resource/resource-settings.js

@@ -0,0 +1,9 @@
+import path from 'node:path';
+import { untildify } from '../utils/utils.js';
+export const ParameterEqualsDefaults = {
+    'boolean': (a, b) => Boolean(a) === Boolean(b),
+    'directory': (a, b) => path.resolve(untildify(String(a))) === path.resolve(untildify(String(b))),
+    'number': (a, b) => Number(a) === Number(b),
+    'string': (a, b) => String(a) === String(b),
+    'version': (desired, current) => String(current).includes(String(desired))
+};

package/dist/resource/resource.d.ts

@@ -0,0 +1,137 @@
+import { StringIndexedObject } from 'codify-schemas';
+import { ParameterChange } from '../plan/change-set.js';
+import { CreatePlan, DestroyPlan, ModifyPlan } from '../plan/plan-types.js';
+import { ResourceSettings } from './resource-settings.js';
+/**
+ * A resource represents an object on the system (application, CLI tool, or setting)
+ * that has state and can be created and destroyed. Examples of resources include CLI tools
+ * like homebrew, docker, and xcode-tools; applications like Google Chrome, Zoom, and OpenVPN;
+ * and settings like AWS profiles, git configs and system preference settings.
+ */
+export declare abstract class Resource<T extends StringIndexedObject> {
+    /**
+     * Return the settings for the resource. Consult the typing for {@link ResourceSettings} for
+     * a description of the options.
+     *
+     * **Parameters**:
+     * - id: The id of the resource. This translates to the `type` id parameter in codify.json configs
+     * - schema: A JSON schema used to validate user input
+     * - allowMultiple: Allow multiple copies of the resource to exist at the same time. If true then,
+     * a matcher must be defined that matches a user defined config and a single resource on the system.
+     * - removeStatefulParametersBeforeDestory: Call the delete methods of stateful parameters before destorying
+     * the base resource. Defaults to false.
+     * - dependencies: Specify the ids of any resources that this resource depends on
+     * - parameterSettings: Parameter specific settings. Use this to define custom equals functions, default values
+     * and input transformations
+     * - inputTransformation: Transform the input value.
+     *
+     * @return ResourceSettings The resource settings
+     */
+    abstract getSettings(): ResourceSettings<T>;
+    initialize(): Promise<void>;
+    /**
+     * Add custom validation logic in-addition to the default schema validation.
+     * In this method throw an error if the object did not validate. The message of the
+     * error will be shown to the user.
+     * @param parameters
+     */
+    validate(parameters: Partial<T>): Promise<void>;
+    /**
+     * Return the status of the resource on the system. If multiple resources exist, then return all instances of
+     * the resource back. Query for the individual parameters specified in the parameter param.
+     * Return null if the resource does not exist.
+     *
+     * Example (Android Studios Resource):
+     * 1. Receive Input:
+     * ```
+     * {
+     *   name: 'Android Studios.app'
+     *   directory: '/Application',
+     *   version: '2023.2'
+     * }
+     * ```
+     * 2. Query the system for any installed Android studio versions.
+     * 3. In this example we find that there is an 2023.2 version installed and an
+     * additional 2024.3-beta version installed as well.
+     * 4. We would return:
+     * ```
+     * [
+     *   { name: 'Android Studios.app', directory: '/Application', version: '2023.2' },
+     *   { name: 'Android Studios Preview.app', directory: '/Application', version: '2024.3' },
+     * ]
+     * ```
+     *
+     * @param parameters The parameters to refresh. In stateless mode this will be the parameters
+     * of the desired config. In stateful mode, this will be parameters of the state config + the desired
+     * config of any new parameters.
+     *
+     * @return A config or an array of configs representing the status of the resource on the
+     * system currently
+     */
+    abstract refresh(parameters: Partial<T>): Promise<Array<Partial<T>> | Partial<T> | null>;
+    /**
+     * Create the resource (install) based on the parameters passed in. Only the desired parameters will
+     * be non-null because in a CREATE plan, the current value is null.
+     *
+     * Example (Android Studios Resource):
+     * 1. We receive a plan of:
+     * ```
+     * Plan {
+     *   desiredConfig: {
+     *     name: 'Android Studios.app',
+     *     directory: '/Application',
+     *     version: '2023.2'
+     *   }
+     *   currentConfig: null,
+     * }
+     * ```
+     * 2. Install version Android Studios 2023.2 and then return.
+     *
+     * @param plan The plan of what to install. Use only the desiredConfig because currentConfig is null.
+     */
+    abstract create(plan: CreatePlan<T>): Promise<void>;
+    /**
+     * Modify a single parameter of a resource. Modify is optional to override and is only called
+     * when a resourceSetting was set to `canModify = true`. This method should only modify
+     * a single parameter at a time as specified by the first parameter: ParameterChange.
+     *
+     * Example (AWS Profile Resource):
+     * 1. We receive a parameter change of:
+     * ```
+     * {
+     *   name: 'awsAccessKeyId',
+     *   operation: ParameterOperation.MODIFY,
+     *   newValue: '123456',
+     *   previousValue: 'abcdef'
+     * }
+     * ```
+     * 2. Use an if statement to only apply this operation for the parameter `awsAccessKeyId`
+     * 3. Update the value of the `aws_access_key_id` to the `newValue` specified in the parameter change
+     *
+     * @param pc ParameterChange, the parameter name and values to modify on the resource
+     * @param plan The overall plan that triggered the modify operation
+     */
+    modify(pc: ParameterChange<T>, plan: ModifyPlan<T>): Promise<void>;
+    /**
+     * Destroy the resource (uninstall) based on the parameters passed in. Only the current parameters will
+     * be non-null because in a DESTROY plan, the desired value is null. This method will only be called in
+     * stateful mode.
+     *
+     * Example (Android Studios Resource):
+     * 1. We receive a plan of:
+     * ```
+     * Plan {
+     *   currentConfig: {
+     *     name: 'Android Studios.app',
+     *     directory: '/Application',
+     *     version: '2022.4'
+     *   },
+     *   desiredConfig: null
+     * }
+     * ```
+     * 2. Uninstall version Android Studios 2022.4 and then return.
+     *
+     * @param plan The plan of what to uninstall. Use only the currentConfig because desiredConfig is null.
+     */
+    abstract destroy(plan: DestroyPlan<T>): Promise<void>;
+}

package/dist/resource/resource.js

@@ -0,0 +1,44 @@
+/**
+ * A resource represents an object on the system (application, CLI tool, or setting)
+ * that has state and can be created and destroyed. Examples of resources include CLI tools
+ * like homebrew, docker, and xcode-tools; applications like Google Chrome, Zoom, and OpenVPN;
+ * and settings like AWS profiles, git configs and system preference settings.
+ */
+export class Resource {
+    async initialize() {
+    }
+    ;
+    /**
+     * Add custom validation logic in-addition to the default schema validation.
+     * In this method throw an error if the object did not validate. The message of the
+     * error will be shown to the user.
+     * @param parameters
+     */
+    async validate(parameters) {
+    }
+    ;
+    /**
+     * Modify a single parameter of a resource. Modify is optional to override and is only called
+     * when a resourceSetting was set to `canModify = true`. This method should only modify
+     * a single parameter at a time as specified by the first parameter: ParameterChange.
+     *
+     * Example (AWS Profile Resource):
+     * 1. We receive a parameter change of:
+     * ```
+     * {
+     *   name: 'awsAccessKeyId',
+     *   operation: ParameterOperation.MODIFY,
+     *   newValue: '123456',
+     *   previousValue: 'abcdef'
+     * }
+     * ```
+     * 2. Use an if statement to only apply this operation for the parameter `awsAccessKeyId`
+     * 3. Update the value of the `aws_access_key_id` to the `newValue` specified in the parameter change
+     *
+     * @param pc ParameterChange, the parameter name and values to modify on the resource
+     * @param plan The overall plan that triggered the modify operation
+     */
+    async modify(pc, plan) {
+    }
+    ;
+}

package/dist/resource/stateful-parameter.d.ts

@@ -0,0 +1,164 @@
+import { StringIndexedObject } from 'codify-schemas';
+import { Plan } from '../plan/plan.js';
+import { ArrayParameterSetting, ParameterSetting } from './resource-settings.js';
+/**
+ * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
+ * is still tied to the overall lifecycle of a resource.
+ *
+ * **Examples include:**
+ * 1. Homebrew formulas are stateful parameters. They can be installed and uninstalled but they are still tied to the
+ * overall lifecycle of homebrew
+ * 2. Nvm installed node versions are stateful parameters. Nvm can install and uninstall different versions of Node but
+ * these versions are tied to the lifecycle of nvm. If nvm is uninstalled then so are the Node versions.
+ */
+export declare abstract class StatefulParameter<T extends StringIndexedObject, V extends T[keyof T]> {
+    /**
+     * Parameter settings for the stateful parameter. Stateful parameters share the same parameter settings as
+     * regular parameters except that they cannot be of type 'stateful'. See {@link ParameterSetting} for more
+     * information on available settings.
+     *
+     * @return The parameter settings
+     */
+    getSettings(): ParameterSetting;
+    /**
+     * Refresh the status of the stateful parameter on the system. This method works similarly to {@link Resource.refresh}.
+     * Return the value of the stateful parameter or null if not found.
+     *
+     * @param desired The desired value of the user.
+     *
+     * @return The value of the stateful parameter currently on the system or null if not found
+     */
+    abstract refresh(desired: V | null): Promise<V | null>;
+    /**
+     * Create the stateful parameter on the system. This method is similar {@link Resource.create} except that its only
+     * applicable to the stateful parameter. For resource `CREATE` operations, this method will be called after the
+     * resource is successfully created. The add method is called when a ParameterChange is ADD in a plan. The add
+     * method is only called when the stateful parameter does not currently exist.
+     *
+     * **Example (Homebrew formula):**
+     * 1. Add is called with a value of:
+     * ```
+     * ['jq', 'jenv']
+     * ```
+     * 2. Add handles the request by calling `brew install --formulae jq jenv`
+     *
+     * @param valueToAdd The desired value of the stateful parameter.
+     * @param plan The overall plan that contains the ADD
+     */
+    abstract add(valueToAdd: V, plan: Plan<T>): Promise<void>;
+    /**
+     * Modify the state of a stateful parameter on the system. This method is similar to {@link Resource.modify} except that its only
+     * applicable to the stateful parameter.
+     *
+     * **Example (Git email parameter):**
+     * 1. Add is called with a value of:
+     * ```
+     * newValue: 'email+new@gmail.com', previousValue: 'email+old@gmail.com'
+     * ```
+     * 2. Modify handles the request by calling `git config --global user.email email+new@gmail.com`
+     *
+     * @param newValue The desired value of the stateful parameter
+     * @param previousValue The current value of the stateful parameter
+     * @param plan The overall plan
+     */
+    abstract modify(newValue: V, previousValue: V, plan: Plan<T>): Promise<void>;
+    /**
+     * Create the stateful parameter on the system. This method is similar {@link Resource.destroy} except that its only
+     * applicable to the stateful parameter. The remove method is only called when the stateful parameter already currently exist.
+     * This method corresponds to REMOVE parameter operations in a plan.
+     * For resource `DESTORY`, this method is only called if the {@link ResourceSettings.removeStatefulParametersBeforeDestroy}
+     * is set to true. This method will be called before the resource is destroyed.
+     *
+     * **Example (Homebrew formula):**
+     * 1. Remove is called with a value of:
+     * ```
+     * ['jq', 'jenv']
+     * ```
+     * 2. Remove handles the request by calling `brew uninstall --formulae jq jenv`
+     *
+     * @param valueToRemove The value to remove from the stateful parameter.
+     * @param plan The overall plan that contains the REMOVE
+     */
+    abstract remove(valueToRemove: V, plan: Plan<T>): Promise<void>;
+}
+/**
+ * A specialized version of {@link StatefulParameter } that is used for stateful parameters which are arrays.
+ * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
+ * is still tied to the overall lifecycle of a resource.
+ *
+ * **Examples:**
+ * - Homebrew formulas are arrays
+ * - Pyenv python versions are arrays
+ */
+export declare abstract class ArrayStatefulParameter<T extends StringIndexedObject, V> extends StatefulParameter<T, any> {
+    /**
+     * Parameter level settings. Type must be 'array'.
+     */
+    getSettings(): ArrayParameterSetting;
+    /**
+     * It is not recommended to override the `add` method. A addItem helper method is available to operate on
+     * individual elements of the desired array. See {@link StatefulParameter.add} for more info.
+     *
+     * @param valuesToAdd The array of values to add
+     * @param plan The overall plan
+     *
+     */
+    add(valuesToAdd: V[], plan: Plan<T>): Promise<void>;
+    /**
+     * It is not recommended to override the `modify` method. `addItem` and `removeItem` will be called accordingly based
+     * on the modifications. See {@link StatefulParameter.modify} for more info.
+     *
+     * @param newValues The new array value
+     * @param previousValues The previous array value
+     * @param plan The overall plan
+     */
+    modify(newValues: V[], previousValues: V[], plan: Plan<T>): Promise<void>;
+    /**
+     * It is not recommended to override the `remove` method. A removeItem helper method is available to operate on
+     * individual elements of the desired array. See {@link StatefulParameter.remove} for more info.
+     *
+     * @param valuesToAdd The array of values to add
+     * @param plan The overall plan
+     *
+     */
+    remove(valuesToRemove: V[], plan: Plan<T>): Promise<void>;
+    /**
+     * See {@link StatefulParameter.refresh} for more info.
+     *
+     * @param desired The desired value to refresh
+     * @return The current value on the system or null if not found.
+     */
+    abstract refresh(desired: V[] | null): Promise<V[] | null>;
+    /**
+     * Helper method that gets called when individual elements of the array need to be added. See {@link StatefulParameter.add}
+     * for more information.
+     *
+     * Example (Homebrew formula):
+     * 1. The stateful parameter receives an input of:
+     * ```
+     * ['jq', 'jenv', 'docker']
+     * ```
+     * 2. Internally the stateful parameter will iterate the array and call `addItem` for each element
+     * 3. Override addItem and install each formula using `brew install --formula jq`
+     *
+     * @param item The item to add (install)
+     * @param plan The overall plan
+     */
+    abstract addItem(item: V, plan: Plan<T>): Promise<void>;
+    /**
+     * Helper method that gets called when individual elements of the array need to be removed. See {@link StatefulParameter.remove}
+     * for more information.
+     *
+     * Example (Homebrew formula):
+     * 1. The stateful parameter receives an input of:
+     * ```
+     * ['jq', 'jenv', 'docker']
+     * ```
+     * 2. Internally the stateful parameter will iterate the array and call `removeItem` for each element
+     * 3. Override removeItem and uninstall each formula using `brew uninstall --formula jq`
+     *
+     * @param item The item to remove (uninstall)
+     * @param plan The overall plan
+     */
+    abstract removeItem(item: V, plan: Plan<T>): Promise<void>;
+}

package/dist/resource/stateful-parameter.js

@@ -0,0 +1,94 @@
+/**
+ * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
+ * is still tied to the overall lifecycle of a resource.
+ *
+ * **Examples include:**
+ * 1. Homebrew formulas are stateful parameters. They can be installed and uninstalled but they are still tied to the
+ * overall lifecycle of homebrew
+ * 2. Nvm installed node versions are stateful parameters. Nvm can install and uninstall different versions of Node but
+ * these versions are tied to the lifecycle of nvm. If nvm is uninstalled then so are the Node versions.
+ */
+export class StatefulParameter {
+    /**
+     * Parameter settings for the stateful parameter. Stateful parameters share the same parameter settings as
+     * regular parameters except that they cannot be of type 'stateful'. See {@link ParameterSetting} for more
+     * information on available settings.
+     *
+     * @return The parameter settings
+     */
+    getSettings() {
+        return {};
+    }
+}
+/**
+ * A specialized version of {@link StatefulParameter } that is used for stateful parameters which are arrays.
+ * A stateful parameter represents a parameter that holds state on the system (can be created, destroyed) but
+ * is still tied to the overall lifecycle of a resource.
+ *
+ * **Examples:**
+ * - Homebrew formulas are arrays
+ * - Pyenv python versions are arrays
+ */
+export class ArrayStatefulParameter extends StatefulParameter {
+    /**
+     * Parameter level settings. Type must be 'array'.
+     */
+    getSettings() {
+        return { type: 'array' };
+    }
+    /**
+     * It is not recommended to override the `add` method. A addItem helper method is available to operate on
+     * individual elements of the desired array. See {@link StatefulParameter.add} for more info.
+     *
+     * @param valuesToAdd The array of values to add
+     * @param plan The overall plan
+     *
+     */
+    async add(valuesToAdd, plan) {
+        for (const value of valuesToAdd) {
+            await this.addItem(value, plan);
+        }
+    }
+    /**
+     * It is not recommended to override the `modify` method. `addItem` and `removeItem` will be called accordingly based
+     * on the modifications. See {@link StatefulParameter.modify} for more info.
+     *
+     * @param newValues The new array value
+     * @param previousValues The previous array value
+     * @param plan The overall plan
+     */
+    async modify(newValues, previousValues, plan) {
+        // TODO: I don't think this works with duplicate elements. Solve at another time
+        const valuesToAdd = newValues.filter((n) => !previousValues.some((p) => {
+            if (this.getSettings()?.isElementEqual) {
+                return this.getSettings().isElementEqual(n, p);
+            }
+            return n === p;
+        }));
+        const valuesToRemove = previousValues.filter((p) => !newValues.some((n) => {
+            if (this.getSettings().isElementEqual) {
+                return this.getSettings().isElementEqual(n, p);
+            }
+            return n === p;
+        }));
+        for (const value of valuesToAdd) {
+            await this.addItem(value, plan);
+        }
+        for (const value of valuesToRemove) {
+            await this.removeItem(value, plan);
+        }
+    }
+    /**
+     * It is not recommended to override the `remove` method. A removeItem helper method is available to operate on
+     * individual elements of the desired array. See {@link StatefulParameter.remove} for more info.
+     *
+     * @param valuesToAdd The array of values to add
+     * @param plan The overall plan
+     *
+     */
+    async remove(valuesToRemove, plan) {
+        for (const value of valuesToRemove) {
+            await this.removeItem(value, plan);
+        }
+    }
+}

package/dist/utils/utils.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
-import { SpawnOptions } from 'child_process';
 import { ResourceConfig, StringIndexedObject } from 'codify-schemas';
+import { SpawnOptions } from 'node:child_process';
+import { ArrayParameterSetting } from '../resource/resource-settings.js';
 export declare enum SpawnStatus {
     SUCCESS = "success",
     ERROR = "error"
@@ -13,13 +14,28 @@ type CodifySpawnOptions = {
     cwd?: string;
     stdioString?: boolean;
 } & SpawnOptions;
+/**
+ *
+ * @param cmd Command to run. Ex: `rm -rf`
+ * @param args Optional additional arguments to append
+ * @param opts Standard options for node spawn. Additional argument:
+ * throws determines if a shell will throw a JS error. Defaults to true
+ * @param extras From PromiseSpawn
+ *
+ * @see promiseSpawn
+ * @see spawn
+ *
+ * @returns SpawnResult { status: SUCCESS | ERROR; data: string }
+ */
 export declare function codifySpawn(cmd: string, args?: string[], opts?: Omit<CodifySpawnOptions, 'stdio' | 'stdioString'> & {
     throws?: boolean;
 }, extras?: Record<any, any>): Promise<SpawnResult>;
 export declare function isDebug(): boolean;
-export declare function splitUserConfig<T extends StringIndexedObject>(config: T & ResourceConfig): {
+export declare function splitUserConfig<T extends StringIndexedObject>(config: ResourceConfig & T): {
     parameters: T;
-    resourceMetadata: ResourceConfig;
+    coreParameters: ResourceConfig;
 };
 export declare function setsEqual(set1: Set<unknown>, set2: Set<unknown>): boolean;
+export declare function untildify(pathWithTilde: string): string;
+export declare function areArraysEqual(parameter: ArrayParameterSetting, desired: unknown, current: unknown): boolean;
 export {};