@codifycli/plugin-core 1.0.0-beta1

package/dist/plan/change-set.d.ts

@@ -0,0 +1,53 @@
+import { ParameterOperation, ResourceOperation, StringIndexedObject } from 'codify-schemas';
+import { ParsedParameterSetting } from '../resource/parsed-resource-settings.js';
+import { ResourceSettings } from '../resource/resource-settings.js';
+/**
+ * A parameter change describes a parameter level change to a resource.
+ */
+export interface ParameterChange<T extends StringIndexedObject> {
+    /**
+     * The name of the parameter
+     */
+    name: keyof T & string;
+    /**
+     * The operation to be performed on the parameter.
+     */
+    operation: ParameterOperation;
+    /**
+     * The previous value of the resource (the current value on the system)
+     */
+    previousValue: any | null;
+    /**
+     * The new value of the resource (the desired value)
+     */
+    newValue: any | null;
+    /**
+     * Whether the parameter is sensitive
+     */
+    isSensitive: boolean;
+}
+export declare class ChangeSet<T extends StringIndexedObject> {
+    operation: ResourceOperation;
+    parameterChanges: Array<ParameterChange<T>>;
+    constructor(operation: ResourceOperation, parameterChanges: Array<ParameterChange<T>>);
+    get desiredParameters(): T;
+    get currentParameters(): T;
+    static empty<T extends StringIndexedObject>(): ChangeSet<T>;
+    static create<T extends StringIndexedObject>(desired: Partial<T>, settings?: ResourceSettings<T>): ChangeSet<T>;
+    static noop<T extends StringIndexedObject>(parameters: Partial<T>, settings?: ResourceSettings<T>): ChangeSet<T>;
+    static destroy<T extends StringIndexedObject>(current: Partial<T>, settings?: ResourceSettings<T>): ChangeSet<T>;
+    static calculateModification<T extends StringIndexedObject>(desired: Partial<T>, current: Partial<T>, parameterSettings?: Partial<Record<keyof T, ParsedParameterSetting>>): ChangeSet<T>;
+    /**
+     * Calculates the differences between the desired and current parameters,
+     * and returns a list of parameter changes that describe what needs to be added,
+     * removed, or modified to match the desired state.
+     *
+     * @param {Partial<T>} desiredParameters - The desired target state of the parameters.
+     * @param {Partial<T>} currentParameters - The current state of the parameters.
+     * @param {Partial<Record<keyof T, ParameterSetting>>} [parameterOptions] - Optional settings used when comparing parameters.
+     * @return {ParameterChange<T>[]} A list of changes required to transition from the current state to the desired state.
+     */
+    private static calculateParameterChanges;
+    private static combineResourceOperations;
+    private static isSame;
+}

package/dist/plan/change-set.js

@@ -0,0 +1,153 @@
+import { ParameterOperation, ResourceOperation } from 'codify-schemas';
+// Change set will coerce undefined values to null because undefined is not valid JSON
+export class ChangeSet {
+    operation;
+    parameterChanges;
+    constructor(operation, parameterChanges) {
+        this.operation = operation;
+        this.parameterChanges = parameterChanges;
+    }
+    get desiredParameters() {
+        return this.parameterChanges
+            .reduce((obj, pc) => ({
+            ...obj,
+            [pc.name]: pc.newValue,
+        }), {});
+    }
+    get currentParameters() {
+        return this.parameterChanges
+            .reduce((obj, pc) => ({
+            ...obj,
+            [pc.name]: pc.previousValue,
+        }), {});
+    }
+    static empty() {
+        return new ChangeSet(ResourceOperation.NOOP, []);
+    }
+    static create(desired, settings) {
+        const parameterChanges = Object.entries(desired)
+            .map(([k, v]) => ({
+            name: k,
+            operation: ParameterOperation.ADD,
+            previousValue: null,
+            newValue: v ?? null,
+            isSensitive: settings?.parameterSettings?.[k]?.isSensitive ?? false,
+        }));
+        return new ChangeSet(ResourceOperation.CREATE, parameterChanges);
+    }
+    static noop(parameters, settings) {
+        const parameterChanges = Object.entries(parameters)
+            .map(([k, v]) => ({
+            name: k,
+            operation: ParameterOperation.NOOP,
+            previousValue: v ?? null,
+            newValue: v ?? null,
+            isSensitive: settings?.parameterSettings?.[k]?.isSensitive ?? false,
+        }));
+        return new ChangeSet(ResourceOperation.NOOP, parameterChanges);
+    }
+    static destroy(current, settings) {
+        const parameterChanges = Object.entries(current)
+            .map(([k, v]) => ({
+            name: k,
+            operation: ParameterOperation.REMOVE,
+            previousValue: v ?? null,
+            newValue: null,
+            isSensitive: settings?.parameterSettings?.[k]?.isSensitive ?? false,
+        }));
+        return new ChangeSet(ResourceOperation.DESTROY, parameterChanges);
+    }
+    static calculateModification(desired, current, parameterSettings = {}) {
+        const pc = ChangeSet.calculateParameterChanges(desired, current, parameterSettings);
+        const statefulParameterKeys = new Set(Object.entries(parameterSettings)
+            .filter(([, v]) => v?.type === 'stateful')
+            .map(([k]) => k));
+        const resourceOperation = pc
+            .filter((change) => change.operation !== ParameterOperation.NOOP)
+            .reduce((operation, curr) => {
+            let newOperation;
+            if (statefulParameterKeys.has(curr.name)) {
+                newOperation = ResourceOperation.MODIFY; // All stateful parameters are modify only
+            }
+            else if (parameterSettings[curr.name]?.canModify) {
+                newOperation = ResourceOperation.MODIFY;
+            }
+            else {
+                newOperation = ResourceOperation.RECREATE; // Default to Re-create. Should handle the majority of use cases
+            }
+            return ChangeSet.combineResourceOperations(operation, newOperation);
+        }, ResourceOperation.NOOP);
+        return new ChangeSet(resourceOperation, pc);
+    }
+    /**
+     * Calculates the differences between the desired and current parameters,
+     * and returns a list of parameter changes that describe what needs to be added,
+     * removed, or modified to match the desired state.
+     *
+     * @param {Partial<T>} desiredParameters - The desired target state of the parameters.
+     * @param {Partial<T>} currentParameters - The current state of the parameters.
+     * @param {Partial<Record<keyof T, ParameterSetting>>} [parameterOptions] - Optional settings used when comparing parameters.
+     * @return {ParameterChange<T>[]} A list of changes required to transition from the current state to the desired state.
+     */
+    static calculateParameterChanges(desiredParameters, currentParameters, parameterOptions) {
+        const parameterChangeSet = new Array();
+        // Filter out null and undefined values or else the diff below will not work
+        const desired = Object.fromEntries(Object.entries(desiredParameters).filter(([, v]) => v !== null && v !== undefined));
+        const current = Object.fromEntries(Object.entries(currentParameters).filter(([, v]) => v !== null && v !== undefined));
+        for (const k of new Set([...Object.keys(current), ...Object.keys(desired)])) {
+            if (ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
+                parameterChangeSet.push({
+                    name: k,
+                    previousValue: current[k] ?? null,
+                    newValue: desired[k] ?? null,
+                    operation: ParameterOperation.NOOP,
+                    isSensitive: parameterOptions?.[k]?.isSensitive ?? false,
+                });
+                continue;
+            }
+            if ((desired?.[k] === null || desired?.[k] === undefined) && (current?.[k] !== null && current?.[k] !== undefined)) {
+                parameterChangeSet.push({
+                    name: k,
+                    previousValue: current[k] ?? null,
+                    newValue: null,
+                    operation: ParameterOperation.REMOVE,
+                    isSensitive: parameterOptions?.[k]?.isSensitive ?? false,
+                });
+                continue;
+            }
+            if ((current?.[k] === null || current?.[k] === undefined) && (desired?.[k] !== null && desired?.[k] !== undefined)) {
+                parameterChangeSet.push({
+                    name: k,
+                    previousValue: null,
+                    newValue: desired[k] ?? null,
+                    operation: ParameterOperation.ADD,
+                    isSensitive: parameterOptions?.[k]?.isSensitive ?? false,
+                });
+                continue;
+            }
+            parameterChangeSet.push({
+                name: k,
+                previousValue: current[k] ?? null,
+                newValue: desired[k] ?? null,
+                operation: ParameterOperation.MODIFY,
+                isSensitive: parameterOptions?.[k]?.isSensitive ?? false,
+            });
+        }
+        return parameterChangeSet;
+    }
+    static combineResourceOperations(prev, next) {
+        const orderOfOperations = [
+            ResourceOperation.NOOP,
+            ResourceOperation.MODIFY,
+            ResourceOperation.RECREATE,
+            ResourceOperation.CREATE,
+            ResourceOperation.DESTROY,
+        ];
+        const indexPrev = orderOfOperations.indexOf(prev);
+        const indexNext = orderOfOperations.indexOf(next);
+        return orderOfOperations[Math.max(indexPrev, indexNext)];
+    }
+    static isSame(desired, current, setting) {
+        return (setting?.isEqual ?? ((a, b) => a === b))(desired, current);
+    }
+}

package/dist/plan/plan-types.d.ts

@@ -0,0 +1,23 @@
+import { StringIndexedObject } from 'codify-schemas';
+import { Plan } from './plan.js';
+/**
+ * A narrower type for plans for CREATE operations. Only desiredConfig is not null.
+ */
+export interface CreatePlan<T extends StringIndexedObject> extends Plan<T> {
+    desiredConfig: T;
+    currentConfig: null;
+}
+/**
+ * A narrower type for plans for DESTROY operations. Only currentConfig is not null.
+ */
+export interface DestroyPlan<T extends StringIndexedObject> extends Plan<T> {
+    desiredConfig: null;
+    currentConfig: T;
+}
+/**
+ * A narrower type for plans for MODIFY and RE-CREATE operations.
+ */
+export interface ModifyPlan<T extends StringIndexedObject> extends Plan<T> {
+    desiredConfig: T;
+    currentConfig: T;
+}

package/dist/plan/plan-types.js

@@ -0,0 +1 @@
+export {};

package/dist/plan/plan.d.ts

@@ -0,0 +1,66 @@
+import { ApplyRequestData, PlanResponseData, ResourceConfig, StringIndexedObject } from 'codify-schemas';
+import { ParsedResourceSettings } from '../resource/parsed-resource-settings.js';
+import { ChangeSet } from './change-set.js';
+/**
+ * A plan represents a set of actions that after taken will turn the current resource into the desired one.
+ * A plan consists of list of parameter level changes (ADD, REMOVE, MODIFY or NO-OP) as well as a resource level
+ * operation (CREATE, DESTROY, MODIFY, RE-CREATE, NO-OP).
+ */
+export declare class Plan<T extends StringIndexedObject> {
+    id: string;
+    /**
+     * List of changes to make
+     */
+    changeSet: ChangeSet<T>;
+    /**
+     * Ex: name, type, dependsOn etc. Metadata parameters
+     */
+    coreParameters: ResourceConfig;
+    isStateful: boolean;
+    constructor(id: string, changeSet: ChangeSet<T>, coreParameters: ResourceConfig, isStateful: boolean);
+    /**
+     * The desired config that a plan will achieve after executing all the actions.
+     */
+    get desiredConfig(): T | null;
+    /**
+     * The current config that the plan is changing.
+     */
+    get currentConfig(): T | null;
+    get resourceId(): string;
+    static calculate<T extends StringIndexedObject>(params: {
+        desired: Partial<T> | null;
+        currentArray: Partial<T>[] | null;
+        state: Partial<T> | null;
+        core: ResourceConfig;
+        settings: ParsedResourceSettings<T>;
+        isStateful: boolean;
+    }): Plan<T>;
+    static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues?: Partial<Record<keyof T, unknown>>): Plan<T>;
+    /**
+     * The type (id) of the resource
+     *
+     * @return string
+     */
+    getResourceType(): string;
+    /**
+     * When multiples of the same resource are allowed, this matching function will match a given config with one of the
+     * existing configs on the system. For example if there are multiple versions of Android Studios installed, we can use
+     * the application name and location to match it to our desired configs name and location.
+     *
+     * @param params
+     * @private
+     */
+    private static matchCurrentParameters;
+    /**
+     *  Only keep relevant params for the plan. We don't want to change settings that were not already
+     *  defined.
+     *
+     *  1. In stateless mode, filter current by desired. We only want to know about settings that the user has specified
+     *  2. In stateful mode, filter current by state and desired. We only know about the settings the user has previously set
+     *  or wants to set. If a parameter is not specified then it's not managed by Codify.
+     */
+    private static filterCurrentParams;
+    requiresChanges(): boolean;
+    /** Convert the plan to a JSON response object */
+    toResponse(): PlanResponseData;
+}

package/dist/plan/plan.js

@@ -0,0 +1,328 @@
+import { ParameterOperation, ResourceOperation, } from 'codify-schemas';
+import { v4 as uuidV4 } from 'uuid';
+import { ChangeSet } from './change-set.js';
+/**
+ * A plan represents a set of actions that after taken will turn the current resource into the desired one.
+ * A plan consists of list of parameter level changes (ADD, REMOVE, MODIFY or NO-OP) as well as a resource level
+ * operation (CREATE, DESTROY, MODIFY, RE-CREATE, NO-OP).
+ */
+export class Plan {
+    id;
+    /**
+     * List of changes to make
+     */
+    changeSet;
+    /**
+     * Ex: name, type, dependsOn etc. Metadata parameters
+     */
+    coreParameters;
+    isStateful;
+    constructor(id, changeSet, coreParameters, isStateful) {
+        this.id = id;
+        this.changeSet = changeSet;
+        this.coreParameters = coreParameters;
+        this.isStateful = isStateful;
+    }
+    /**
+     * The desired config that a plan will achieve after executing all the actions.
+     */
+    get desiredConfig() {
+        if (this.changeSet.operation === ResourceOperation.DESTROY) {
+            return null;
+        }
+        return this.changeSet.desiredParameters;
+    }
+    /**
+     * The current config that the plan is changing.
+     */
+    get currentConfig() {
+        if (this.changeSet.operation === ResourceOperation.CREATE) {
+            return null;
+        }
+        return this.changeSet.currentParameters;
+    }
+    get resourceId() {
+        return this.coreParameters.name
+            ? `${this.coreParameters.type}.${this.coreParameters.name}`
+            : this.coreParameters.type;
+    }
+    static calculate(params) {
+        const { desired, currentArray, state, core, settings, isStateful } = params;
+        const current = Plan.matchCurrentParameters({
+            desired,
+            currentArray,
+            state,
+            settings,
+            isStateful
+        });
+        const filteredCurrentParameters = Plan.filterCurrentParams({
+            desired,
+            current,
+            state,
+            settings,
+            isStateful
+        });
+        // Empty
+        if (!filteredCurrentParameters && !desired) {
+            return new Plan(uuidV4(), ChangeSet.empty(), core, isStateful);
+        }
+        // CREATE
+        if (!filteredCurrentParameters && desired) {
+            return new Plan(uuidV4(), ChangeSet.create(desired, settings), core, isStateful);
+        }
+        // DESTROY
+        if (filteredCurrentParameters && !desired) {
+            // We can manually override destroys. If a resource cannot be destroyed (for instance the npm resource relies on NodeJS being created and destroyed)
+            if (!settings.canDestroy) {
+                return new Plan(uuidV4(), ChangeSet.noop(filteredCurrentParameters, settings), core, isStateful);
+            }
+            return new Plan(uuidV4(), ChangeSet.destroy(filteredCurrentParameters, settings), core, isStateful);
+        }
+        // NO-OP, MODIFY or RE-CREATE
+        const changeSet = ChangeSet.calculateModification(desired, filteredCurrentParameters, settings.parameterSettings);
+        return new Plan(uuidV4(), changeSet, core, isStateful);
+    }
+    //   2. Even if there was (maybe for testing reasons), the plan values should not be adjusted
+    static fromResponse(data, defaultValues) {
+        if (!data) {
+            throw new Error('Data is empty');
+        }
+        addDefaultValues();
+        return new Plan(uuidV4(), new ChangeSet(data.operation, data.parameters.map((p) => ({
+            ...p,
+            isSensitive: p.isSensitive ?? false,
+        }))), {
+            type: data.resourceType,
+            name: data.resourceName,
+        }, data.isStateful);
+        function addDefaultValues() {
+            Object.entries(defaultValues ?? {})
+                .forEach(([key, defaultValue]) => {
+                const configValueExists = data
+                    .parameters
+                    .some((p) => p.name === key);
+                // Only set default values if the value does not exist in the config
+                if (configValueExists) {
+                    return;
+                }
+                switch (data.operation) {
+                    case ResourceOperation.CREATE: {
+                        data.parameters.push({
+                            name: key,
+                            operation: ParameterOperation.ADD,
+                            previousValue: null,
+                            newValue: defaultValue,
+                        });
+                        break;
+                    }
+                    case ResourceOperation.DESTROY: {
+                        data.parameters.push({
+                            name: key,
+                            operation: ParameterOperation.REMOVE,
+                            previousValue: defaultValue,
+                            newValue: null,
+                        });
+                        break;
+                    }
+                    case ResourceOperation.MODIFY:
+                    case ResourceOperation.RECREATE:
+                    case ResourceOperation.NOOP: {
+                        data.parameters.push({
+                            name: key,
+                            operation: ParameterOperation.NOOP,
+                            previousValue: defaultValue,
+                            newValue: defaultValue,
+                        });
+                        break;
+                    }
+                }
+            });
+        }
+    }
+    /**
+     * The type (id) of the resource
+     *
+     * @return string
+     */
+    getResourceType() {
+        return this.coreParameters.type;
+    }
+    /**
+     * When multiples of the same resource are allowed, this matching function will match a given config with one of the
+     * existing configs on the system. For example if there are multiple versions of Android Studios installed, we can use
+     * the application name and location to match it to our desired configs name and location.
+     *
+     * @param params
+     * @private
+     */
+    static matchCurrentParameters(params) {
+        const { desired, currentArray, state, settings, isStateful } = params;
+        if (!settings.allowMultiple) {
+            return currentArray?.[0] ?? null;
+        }
+        if (!currentArray) {
+            return null;
+        }
+        const { matcher: parameterMatcher, id } = settings;
+        const matcher = (desired, currentArray) => {
+            const matched = currentArray.filter((c) => parameterMatcher(desired, c));
+            if (matched.length > 1) {
+                console.log(`Resource: ${id} did not uniquely match resources when allow multiple is set to true`);
+            }
+            return matched[0];
+        };
+        if (isStateful) {
+            return state
+                ? matcher(state, currentArray) ?? null
+                : null;
+        }
+        return matcher(desired, currentArray) ?? null;
+    }
+    /**
+     *  Only keep relevant params for the plan. We don't want to change settings that were not already
+     *  defined.
+     *
+     *  1. In stateless mode, filter current by desired. We only want to know about settings that the user has specified
+     *  2. In stateful mode, filter current by state and desired. We only know about the settings the user has previously set
+     *  or wants to set. If a parameter is not specified then it's not managed by Codify.
+     */
+    static filterCurrentParams(params) {
+        const { desired, current, state, settings, isStateful } = params;
+        if (!current) {
+            return null;
+        }
+        const filteredCurrent = filterCurrent();
+        if (!filteredCurrent) {
+            return null;
+        }
+        // For stateful mode, we're done after filtering by the keys of desired + state. Stateless mode
+        // requires additional filtering for stateful parameter arrays and objects.
+        if (isStateful && desired) {
+            return filteredCurrent;
+        }
+        // We also want to filter parameters when in delete mode. We don't want to delete parameters that
+        // are not specified in the original config.
+        if (isStateful && !desired) {
+            const arrayStatefulParameters = Object.fromEntries(Object.entries(filteredCurrent)
+                .filter(([k, v]) => isArrayParameterWithFiltering(k, v))
+                .map(([k, v]) => [k, filterArrayParameterForDeletes(k, v)]));
+            return { ...filteredCurrent, ...arrayStatefulParameters };
+        }
+        // TODO: Add object handling here in addition to arrays in the future
+        const arrayStatefulParameters = Object.fromEntries(Object.entries(filteredCurrent)
+            .filter(([k, v]) => isArrayParameterWithFiltering(k, v))
+            .map(([k, v]) => [k, filterArrayParameterForStatelessMode(k, v)]));
+        return { ...filteredCurrent, ...arrayStatefulParameters };
+        function filterCurrent() {
+            if (!current) {
+                return null;
+            }
+            if (isStateful) {
+                const keys = new Set([...Object.keys(state ?? {}), ...Object.keys(desired ?? {})]);
+                return Object.fromEntries(Object.entries(current)
+                    .filter(([k]) => keys.has(k)));
+            }
+            // Stateless mode
+            const keys = new Set(Object.keys(desired ?? {}));
+            return Object.fromEntries(Object.entries(current)
+                .filter(([k]) => keys.has(k)));
+        }
+        function getFilterParameter(k) {
+            if (settings.parameterSettings?.[k]?.type === 'stateful') {
+                const statefulSetting = settings.parameterSettings[k];
+                if (statefulSetting.nestedSettings.type === 'array') {
+                    return statefulSetting.nestedSettings.filterInStatelessMode;
+                }
+            }
+            if (settings.parameterSettings?.[k]?.type === 'array') {
+                return (settings.parameterSettings?.[k]).filterInStatelessMode;
+            }
+            return undefined;
+        }
+        function isArrayParameterWithFiltering(k, v) {
+            const filterParameter = getFilterParameter(k);
+            if (settings.parameterSettings?.[k]?.type === 'stateful') {
+                const statefulSetting = settings.parameterSettings[k];
+                return statefulSetting.nestedSettings.type === 'array' &&
+                    (filterParameter ?? true)
+                    && Array.isArray(v);
+            }
+            return settings.parameterSettings?.[k]?.type === 'array'
+                && (filterParameter ?? true)
+                && Array.isArray(v);
+        }
+        // For stateless mode, we must filter the current array so that the diff algorithm will not detect any deletes
+        function filterArrayParameterForStatelessMode(k, v) {
+            const desiredArray = desired[k];
+            const matcher = settings.parameterSettings[k].type === 'stateful'
+                ? settings.parameterSettings[k]
+                    .nestedSettings
+                    .isElementEqual
+                : settings.parameterSettings[k]
+                    .isElementEqual;
+            const desiredCopy = [...desiredArray];
+            const currentCopy = [...v];
+            const defaultFilterMethod = ((desired, current) => {
+                const result = [];
+                for (let counter = desired.length - 1; counter >= 0; counter--) {
+                    const idx = currentCopy.findIndex((e2) => matcher(desired[counter], e2));
+                    if (idx === -1) {
+                        continue;
+                    }
+                    desired.splice(counter, 1);
+                    const [element] = current.splice(idx, 1);
+                    result.push(element);
+                }
+                return result;
+            });
+            const filterParameter = getFilterParameter(k);
+            return typeof filterParameter === 'function'
+                ? filterParameter(desiredCopy, currentCopy)
+                : defaultFilterMethod(desiredCopy, currentCopy);
+        }
+        function filterArrayParameterForDeletes(k, v) {
+            const stateArray = state[k];
+            const matcher = settings.parameterSettings[k].type === 'stateful'
+                ? settings.parameterSettings[k]
+                    .nestedSettings
+                    .isElementEqual
+                : settings.parameterSettings[k]
+                    .isElementEqual;
+            const stateCopy = [...stateArray];
+            const currentCopy = [...v];
+            const defaultFilterMethod = ((state, current) => {
+                const result = [];
+                for (let counter = state.length - 1; counter >= 0; counter--) {
+                    const idx = currentCopy.findIndex((e2) => matcher(state[counter], e2));
+                    if (idx === -1) {
+                        continue;
+                    }
+                    state.splice(counter, 1);
+                    const [element] = current.splice(idx, 1);
+                    result.push(element);
+                }
+                return result;
+            });
+            const filterParameter = getFilterParameter(k);
+            return typeof filterParameter === 'function'
+                ? filterParameter(stateCopy, currentCopy)
+                : defaultFilterMethod(stateCopy, currentCopy);
+        }
+    }
+    // TODO: This needs to be revisited. I don't think this is valid anymore.
+    //   1. For all scenarios, there shouldn't be an apply without a plan beforehand
+    requiresChanges() {
+        return this.changeSet.operation !== ResourceOperation.NOOP;
+    }
+    /** Convert the plan to a JSON response object */
+    toResponse() {
+        return {
+            planId: this.id,
+            operation: this.changeSet.operation,
+            isStateful: this.isStateful,
+            resourceName: this.coreParameters.name,
+            resourceType: this.coreParameters.type,
+            parameters: this.changeSet.parameterChanges,
+        };
+    }
+}

package/dist/plugin/plugin.d.ts

@@ -0,0 +1,24 @@
+import { ApplyRequestData, GetResourceInfoRequestData, GetResourceInfoResponseData, ImportRequestData, ImportResponseData, InitializeRequestData, InitializeResponseData, MatchRequestData, MatchResponseData, PlanRequestData, PlanResponseData, ResourceConfig, ResourceJson, SetVerbosityRequestData, ValidateRequestData, ValidateResponseData } from 'codify-schemas';
+import { Plan } from '../plan/plan.js';
+import { BackgroundPty } from '../pty/background-pty.js';
+import { Resource } from '../resource/resource.js';
+import { ResourceController } from '../resource/resource-controller.js';
+export declare class Plugin {
+    name: string;
+    resourceControllers: Map<string, ResourceController<ResourceConfig>>;
+    planStorage: Map<string, Plan<any>>;
+    planPty: BackgroundPty;
+    constructor(name: string, resourceControllers: Map<string, ResourceController<ResourceConfig>>);
+    static create(name: string, resources: Resource<any>[]): Plugin;
+    initialize(data: InitializeRequestData): Promise<InitializeResponseData>;
+    getResourceInfo(data: GetResourceInfoRequestData): GetResourceInfoResponseData;
+    match(data: MatchRequestData): Promise<MatchResponseData>;
+    import(data: ImportRequestData): Promise<ImportResponseData>;
+    validate(data: ValidateRequestData): Promise<ValidateResponseData>;
+    plan(data: PlanRequestData): Promise<PlanResponseData>;
+    apply(data: ApplyRequestData): Promise<void>;
+    setVerbosityLevel(data: SetVerbosityRequestData): Promise<void>;
+    kill(): Promise<void>;
+    private resolvePlan;
+    protected crossValidateResources(resources: ResourceJson[]): Promise<void>;
+}