@codifycli/plugin-core 1.2.0 → 1.2.1

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

@@ -49,5 +49,6 @@ export declare class ChangeSet<T extends StringIndexedObject> {
      */
     private static calculateParameterChanges;
     private static combineResourceOperations;
+    private static isAbsent;
     private static isSame;
 }

package/dist/plan/change-set.js

@@ -92,9 +92,9 @@ export class ChangeSet {
      */
     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));
+        // Filter out null, undefined, [], and {} — all treated as "no value"
+        const desired = Object.fromEntries(Object.entries(desiredParameters).filter(([, v]) => !ChangeSet.isAbsent(v)));
+        const current = Object.fromEntries(Object.entries(currentParameters).filter(([, v]) => !ChangeSet.isAbsent(v)));
         for (const k of new Set([...Object.keys(current), ...Object.keys(desired)])) {
             if (ChangeSet.isSame(desired[k], current[k], parameterOptions?.[k])) {
                 parameterChangeSet.push({
@@ -148,6 +148,15 @@ export class ChangeSet {
         const indexNext = orderOfOperations.indexOf(next);
         return orderOfOperations[Math.max(indexPrev, indexNext)];
     }
+    static isAbsent(v) {
+        if (v === null || v === undefined)
+            return true;
+        if (Array.isArray(v))
+            return v.length === 0;
+        if (typeof v === 'object')
+            return Object.keys(v).length === 0;
+        return false;
+    }
     static isSame(desired, current, setting) {
         return (setting?.isEqual ?? ((a, b) => a === b))(desired, current);
     }

package/dist/utils/functions.js

@@ -31,7 +31,7 @@ export function resolvePathWithVariables(pathWithVariables) {
 export function addVariablesToPath(pathWithoutVariables) {
     let result = pathWithoutVariables;
     for (const [key, value] of Object.entries(process.env)) {
-        if (!value || !path.isAbsolute(value) || value === '/' || key === 'HOME' || key === 'PATH' || key === 'SHELL' || key === 'PWD') {
+        if (!value || !path.isAbsolute(value) || value === '/' || value === homeDirectory || key === 'HOME' || key === 'PATH' || key === 'SHELL' || key === 'PWD') {
             continue;
         }
         result = result.replaceAll(value, `$${key}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codifycli/plugin-core",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "TypeScript library for building Codify plugins to manage system resources (applications, CLI tools, settings) through infrastructure-as-code",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/plan/change-set.test.ts

@@ -304,6 +304,33 @@ describe('Change set tests', () => {
     expect(cs.operation).to.eq(ResourceOperation.DESTROY);
   })
 
+  it('treats empty objects {} as no-op', () => {
+    const desired = {
+      keyboard: {},
+      dock: {},
+    }
+
+    const current = {
+      keyboard: {},
+      dock: {},
+    }
+
+    const cs = ChangeSet.calculateModification(desired, current);
+    expect(cs.parameterChanges.length).to.eq(0);
+    expect(cs.operation).to.eq(ResourceOperation.NOOP);
+  })
+
+  it('treats empty object {} as absent when current has no value', () => {
+    const desired = {
+      keyboard: {},
+      dock: {},
+    }
+
+    const cs = ChangeSet.calculateModification(desired, {});
+    expect(cs.parameterChanges.length).to.eq(0);
+    expect(cs.operation).to.eq(ResourceOperation.NOOP);
+  })
+
   it('correctly determines array equality 5', () => {
     const arrA = [{ key1: 'b' }, { key1: 'a' }, { key1: 'a' }];
     const arrB = [{ key1: 'a' }, { key1: 'a' }, { key1: 'b' }];

package/src/plan/change-set.ts

@@ -154,13 +154,13 @@ export class ChangeSet<T extends StringIndexedObject> {
   ): ParameterChange<T>[] {
     const parameterChangeSet = new Array<ParameterChange<T>>();
 
-    // Filter out null and undefined values or else the diff below will not work
+    // Filter out null, undefined, [], and {} — all treated as "no value"
     const desired = Object.fromEntries(
-      Object.entries(desiredParameters).filter(([, v]) => v !== null && v !== undefined)
+      Object.entries(desiredParameters).filter(([, v]) => !ChangeSet.isAbsent(v))
     ) as Partial<T>
 
     const current = Object.fromEntries(
-      Object.entries(currentParameters).filter(([, v]) => v !== null && v !== undefined)
+      Object.entries(currentParameters).filter(([, v]) => !ChangeSet.isAbsent(v))
     ) as Partial<T>
 
     for (const k of new Set([...Object.keys(current), ...Object.keys(desired)])) {
@@ -227,6 +227,13 @@ export class ChangeSet<T extends StringIndexedObject> {
     return orderOfOperations[Math.max(indexPrev, indexNext)];
   }
 
+  private static isAbsent(v: unknown): boolean {
+    if (v === null || v === undefined) return true;
+    if (Array.isArray(v)) return v.length === 0;
+    if (typeof v === 'object') return Object.keys(v as object).length === 0;
+    return false;
+  }
+
   private static isSame(
     desired: unknown,
     current: unknown,

package/src/utils/functions.ts

@@ -43,7 +43,7 @@ export function resolvePathWithVariables(pathWithVariables: string) {
 export function addVariablesToPath(pathWithoutVariables: string) {
   let result = pathWithoutVariables;
   for (const [key, value] of Object.entries(process.env)) {
-    if (!value || !path.isAbsolute(value) || value === '/' || key === 'HOME' || key === 'PATH' || key === 'SHELL' || key === 'PWD') {
+    if (!value || !path.isAbsolute(value) || value === '/' || value === homeDirectory || key === 'HOME' || key === 'PATH' || key === 'SHELL' || key === 'PWD') {
       continue;
     }
 

package/.claude/settings.local.json

@@ -1,13 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(grep -r \"COMMAND_REQUEST\\\\|PRESS_KEY_TO_CONTINUE_REQUEST\\\\|CODIFY_CREDENTIALS_REQUEST\" /Users/kevinwang/Projects/codify-parent/codify/src --include=\"*.ts\" ! -name \"*.test.ts\")",
-      "Read(//Users/kevinwang/Projects/codify-parent/codify-schemas/**)",
-      "Bash(npm run *)"
-    ]
-  },
-  "disabledMcpjsonServers": [
-    "supabase",
-    "codify"
-  ]
-}

package/dist/bin/build.d.ts

@@ -1 +0,0 @@
-export declare function build(): Promise<void>;

package/dist/bin/build.js

@@ -1,80 +0,0 @@
-import { Ajv } from 'ajv';
-import { IpcMessageSchema, MessageStatus, ResourceSchema } from 'codify-schemas';
-// @ts-ignore
-import mergeJsonSchemas from 'merge-json-schemas';
-import { fork } from 'node:child_process';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import * as url from 'node:url';
-import { codifySpawn } from '../utils/codify-spawn.js';
-const ajv = new Ajv({
-    strict: true
-});
-const ipcMessageValidator = ajv.compile(IpcMessageSchema);
-function sendMessageAndAwaitResponse(process, message) {
-    return new Promise((resolve, reject) => {
-        process.on('message', (response) => {
-            if (!ipcMessageValidator(response)) {
-                throw new Error(`Invalid message from plugin. ${JSON.stringify(message, null, 2)}`);
-            }
-            // Wait for the message response. Other messages such as sudoRequest may be sent before the response returns
-            if (response.cmd === message.cmd + '_Response') {
-                if (response.status === MessageStatus.SUCCESS) {
-                    resolve(response.data);
-                }
-                else {
-                    reject(new Error(String(response.data)));
-                }
-            }
-        });
-        // Send message last to ensure listeners are all registered
-        process.send(message);
-    });
-}
-export async function build() {
-    await fs.rm('./dist', { force: true, recursive: true });
-    await codifySpawn('npm run rollup -- -f es');
-    const plugin = fork('./dist/index.js', [], {
-        // Use default true to test plugins in secure mode (un-able to request sudo directly)
-        detached: true,
-        env: { ...process.env },
-        execArgv: ['--import', 'tsx/esm'],
-    });
-    const initializeResult = await sendMessageAndAwaitResponse(plugin, {
-        cmd: 'initialize',
-        data: {}
-    });
-    const { resourceDefinitions } = initializeResult;
-    const resourceTypes = resourceDefinitions.map((i) => i.type);
-    const schemasMap = new Map();
-    for (const type of resourceTypes) {
-        const resourceInfo = await sendMessageAndAwaitResponse(plugin, {
-            cmd: 'getResourceInfo',
-            data: { type }
-        });
-        schemasMap.set(type, resourceInfo.schema);
-    }
-    const mergedSchemas = [...schemasMap.entries()].map(([type, schema]) => {
-        // const resolvedSchema = await $RefParser.dereference(schema)
-        const resourceSchema = JSON.parse(JSON.stringify(ResourceSchema));
-        delete resourceSchema.$id;
-        delete resourceSchema.$schema;
-        delete resourceSchema.title;
-        delete resourceSchema.oneOf;
-        delete resourceSchema.properties.type;
-        if (schema) {
-            delete schema.$id;
-            delete schema.$schema;
-            delete schema.title;
-            delete schema.oneOf;
-        }
-        return mergeJsonSchemas([schema ?? {}, resourceSchema, { properties: { type: { const: type, type: 'string' } } }]);
-    });
-    await fs.rm('./dist', { force: true, recursive: true });
-    await codifySpawn('npm run rollup'); // re-run rollup without building for es
-    console.log('Generated JSON Schemas for all resources');
-    const distFolder = path.resolve(path.dirname(url.fileURLToPath(import.meta.url)), '..', 'dist');
-    const schemaOutputPath = path.resolve(distFolder, 'schemas.json');
-    await fs.writeFile(schemaOutputPath, JSON.stringify(mergedSchemas, null, 2));
-    console.log('Successfully wrote schema to ./dist/schemas.json');
-}

package/dist/bin/deploy-plugin.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/bin/deploy-plugin.js

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-import path from 'node:path';
-import * as fs from 'node:fs';
-import { build } from './build.js';
-const packageJson = fs.readFileSync(path.join(process.env['npm_config_local_prefix'], 'package.json'), 'utf8');
-const { name: libraryName, version: libraryVersion } = JSON.parse(packageJson);
-console.log(libraryName, libraryVersion);
-await build();

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

@@ -1,24 +0,0 @@
-import { ParameterOperation, ResourceOperation, StringIndexedObject } from 'codify-schemas';
-import { ParameterOptions } from './plan-types.js';
-export interface ParameterChange<T extends StringIndexedObject> {
-    name: keyof T & string;
-    operation: ParameterOperation;
-    previousValue: any | null;
-    newValue: any | null;
-}
-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 calculateParameterChangeSet<T extends StringIndexedObject>(desired: T | null, current: T | null, options: {
-        statefulMode: boolean;
-        parameterOptions?: Record<keyof T, ParameterOptions>;
-    }): ParameterChange<T>[];
-    static combineResourceOperations(prev: ResourceOperation, next: ResourceOperation): ResourceOperation;
-    static isSame(desired: unknown, current: unknown, options?: ParameterOptions): boolean;
-    private static calculateStatefulModeChangeSet;
-    private static calculateStatelessModeChangeSet;
-    private static addDefaultValues;
-}

package/dist/entities/change-set.js

@@ -1,152 +0,0 @@
-import { ParameterOperation, ResourceOperation } from 'codify-schemas';
-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 calculateParameterChangeSet(desired, current, options) {
-        if (options.statefulMode) {
-            return ChangeSet.calculateStatefulModeChangeSet(desired, current, options.parameterOptions);
-        }
-        else {
-            return ChangeSet.calculateStatelessModeChangeSet(desired, current, options.parameterOptions);
-        }
-    }
-    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, options) {
-        if (options?.isEqual) {
-            return options.isEqual(desired, current);
-        }
-        if (Array.isArray(desired) && Array.isArray(current)) {
-            const sortedDesired = desired.map((x) => x).sort();
-            const sortedCurrent = current.map((x) => x).sort();
-            if (sortedDesired.length !== sortedCurrent.length) {
-                return false;
-            }
-            if (options?.isElementEqual) {
-                return sortedDesired.every((value, index) => options.isElementEqual(value, sortedCurrent[index]));
-            }
-            return JSON.stringify(sortedDesired) === JSON.stringify(sortedCurrent);
-        }
-        return desired === current;
-    }
-    static calculateStatefulModeChangeSet(desired, current, parameterOptions) {
-        const parameterChangeSet = new Array();
-        const _desired = Object.fromEntries(Object.entries(desired ?? {}).filter(([, v]) => v != null));
-        const _current = Object.fromEntries(Object.entries(current ?? {}).filter(([, v]) => v != null));
-        this.addDefaultValues(_desired, parameterOptions);
-        for (const [k, v] of Object.entries(_current)) {
-            if (_desired[k] == null) {
-                parameterChangeSet.push({
-                    name: k,
-                    previousValue: v,
-                    newValue: null,
-                    operation: ParameterOperation.REMOVE,
-                });
-                delete _current[k];
-                continue;
-            }
-            if (!ChangeSet.isSame(_desired[k], _current[k], parameterOptions?.[k])) {
-                parameterChangeSet.push({
-                    name: k,
-                    previousValue: v,
-                    newValue: _desired[k],
-                    operation: ParameterOperation.MODIFY,
-                });
-                delete _current[k];
-                delete _desired[k];
-                continue;
-            }
-            parameterChangeSet.push({
-                name: k,
-                previousValue: v,
-                newValue: _desired[k],
-                operation: ParameterOperation.NOOP,
-            });
-            delete _current[k];
-            delete _desired[k];
-        }
-        if (Object.keys(_current).length !== 0) {
-            throw Error('Diff algorithm error');
-        }
-        for (const [k, v] of Object.entries(_desired)) {
-            parameterChangeSet.push({
-                name: k,
-                previousValue: null,
-                newValue: v,
-                operation: ParameterOperation.ADD,
-            });
-        }
-        return parameterChangeSet;
-    }
-    static calculateStatelessModeChangeSet(desired, current, parameterOptions) {
-        const parameterChangeSet = new Array();
-        const _desired = Object.fromEntries(Object.entries(desired ?? {}).filter(([, v]) => v != null));
-        const _current = Object.fromEntries(Object.entries(current ?? {}).filter(([, v]) => v != null));
-        this.addDefaultValues(_desired, parameterOptions);
-        for (const [k, v] of Object.entries(_desired)) {
-            if (_current[k] == null) {
-                parameterChangeSet.push({
-                    name: k,
-                    previousValue: null,
-                    newValue: v,
-                    operation: ParameterOperation.ADD,
-                });
-                continue;
-            }
-            if (!ChangeSet.isSame(_desired[k], _current[k], parameterOptions?.[k])) {
-                parameterChangeSet.push({
-                    name: k,
-                    previousValue: _current[k],
-                    newValue: _desired[k],
-                    operation: ParameterOperation.MODIFY,
-                });
-                continue;
-            }
-            parameterChangeSet.push({
-                name: k,
-                previousValue: v,
-                newValue: v,
-                operation: ParameterOperation.NOOP,
-            });
-        }
-        return parameterChangeSet;
-    }
-    static addDefaultValues(obj, options) {
-        Object.entries(options ?? {})
-            .filter(([, option]) => option.default !== undefined)
-            .map(([name, option]) => [name, option.default])
-            .forEach(([key, defaultValue]) => {
-            if (obj[key] === undefined) {
-                obj[key] = defaultValue;
-            }
-        });
-    }
-}

package/dist/entities/errors.d.ts

@@ -1,4 +0,0 @@
-export declare class SudoError extends Error {
-    command: string;
-    constructor(command: string);
-}

package/dist/entities/errors.js

@@ -1,7 +0,0 @@
-export class SudoError extends Error {
-    command;
-    constructor(command) {
-        super();
-        this.command = command;
-    }
-}

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

@@ -1,25 +0,0 @@
-import { Plan } from './plan.js';
-import { StringIndexedObject } from 'codify-schemas';
-export interface ParameterOptions {
-    modifyOnChange?: boolean;
-    isEqual?: (desired: any, current: any) => boolean;
-    isElementEqual?: (desired: any, current: any) => boolean;
-    default?: unknown;
-    isStatefulParameter?: boolean;
-}
-export interface PlanOptions<T> {
-    statefulMode: boolean;
-    parameterOptions?: Record<keyof T, ParameterOptions>;
-}
-export interface CreatePlan<T extends StringIndexedObject> extends Plan<T> {
-    desiredConfig: T;
-    currentConfig: null;
-}
-export interface DestroyPlan<T extends StringIndexedObject> extends Plan<T> {
-    desiredConfig: null;
-    currentConfig: T;
-}
-export interface ModifyPlan<T extends StringIndexedObject> extends Plan<T> {
-    desiredConfig: T;
-    currentConfig: T;
-}

package/dist/entities/plan-types.js

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

package/dist/entities/plan.d.ts

@@ -1,15 +0,0 @@
-import { ChangeSet } from './change-set.js';
-import { ApplyRequestData, PlanResponseData, ResourceConfig, StringIndexedObject } from 'codify-schemas';
-import { PlanOptions } from './plan-types.js';
-export declare class Plan<T extends StringIndexedObject> {
-    id: string;
-    changeSet: ChangeSet<T>;
-    resourceMetadata: ResourceConfig;
-    constructor(id: string, changeSet: ChangeSet<T>, resourceMetadata: ResourceConfig);
-    static create<T extends StringIndexedObject>(desiredParameters: Partial<T> | null, currentParameters: Partial<T> | null, resourceMetadata: ResourceConfig, options: PlanOptions<T>): Plan<T>;
-    getResourceType(): string;
-    static fromResponse<T extends ResourceConfig>(data: ApplyRequestData['plan'], defaultValues?: Partial<Record<keyof T, unknown>>): Plan<T>;
-    get desiredConfig(): T | null;
-    get currentConfig(): T | null;
-    toResponse(): PlanResponseData;
-}

package/dist/entities/plan.js

@@ -1,127 +0,0 @@
-import { ChangeSet } from './change-set.js';
-import { ParameterOperation, ResourceOperation, } from 'codify-schemas';
-import { randomUUID } from 'crypto';
-export class Plan {
-    id;
-    changeSet;
-    resourceMetadata;
-    constructor(id, changeSet, resourceMetadata) {
-        this.id = id;
-        this.changeSet = changeSet;
-        this.resourceMetadata = resourceMetadata;
-    }
-    static create(desiredParameters, currentParameters, resourceMetadata, options) {
-        const parameterOptions = options.parameterOptions ?? {};
-        const statefulParameterNames = new Set([...Object.entries(parameterOptions)]
-            .filter(([k, v]) => v.isStatefulParameter)
-            .map(([k, v]) => k));
-        const parameterChangeSet = ChangeSet.calculateParameterChangeSet(desiredParameters, currentParameters, { statefulMode: options.statefulMode, parameterOptions });
-        let resourceOperation;
-        if (!currentParameters && desiredParameters) {
-            resourceOperation = ResourceOperation.CREATE;
-        }
-        else if (currentParameters && !desiredParameters) {
-            resourceOperation = ResourceOperation.DESTROY;
-        }
-        else {
-            resourceOperation = parameterChangeSet
-                .filter((change) => change.operation !== ParameterOperation.NOOP)
-                .reduce((operation, curr) => {
-                let newOperation;
-                if (statefulParameterNames.has(curr.name)) {
-                    newOperation = ResourceOperation.MODIFY;
-                }
-                else if (parameterOptions[curr.name]?.modifyOnChange) {
-                    newOperation = parameterOptions[curr.name].modifyOnChange ? ResourceOperation.MODIFY : ResourceOperation.RECREATE;
-                }
-                else {
-                    newOperation = ResourceOperation.RECREATE;
-                }
-                return ChangeSet.combineResourceOperations(operation, newOperation);
-            }, ResourceOperation.NOOP);
-        }
-        return new Plan(randomUUID(), new ChangeSet(resourceOperation, parameterChangeSet), resourceMetadata);
-    }
-    getResourceType() {
-        return this.resourceMetadata.type;
-    }
-    static fromResponse(data, defaultValues) {
-        if (!data) {
-            throw new Error('Data is empty');
-        }
-        addDefaultValues();
-        return new Plan(randomUUID(), new ChangeSet(data.operation, data.parameters), {
-            type: data.resourceType,
-            name: data.resourceName,
-        });
-        function addDefaultValues() {
-            Object.entries(defaultValues ?? {})
-                .forEach(([key, defaultValue]) => {
-                const configValueExists = data
-                    .parameters
-                    .some((p) => p.name === key);
-                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;
-                    }
-                }
-            });
-        }
-    }
-    get desiredConfig() {
-        if (this.changeSet.operation === ResourceOperation.DESTROY) {
-            return null;
-        }
-        return {
-            ...this.resourceMetadata,
-            ...this.changeSet.desiredParameters,
-        };
-    }
-    get currentConfig() {
-        if (this.changeSet.operation === ResourceOperation.CREATE) {
-            return null;
-        }
-        return {
-            ...this.resourceMetadata,
-            ...this.changeSet.currentParameters,
-        };
-    }
-    toResponse() {
-        return {
-            planId: this.id,
-            operation: this.changeSet.operation,
-            resourceName: this.resourceMetadata.name,
-            resourceType: this.resourceMetadata.type,
-            parameters: this.changeSet.parameterChanges,
-        };
-    }
-}

package/dist/entities/plugin.d.ts

@@ -1,16 +0,0 @@
-import { ApplyRequestData, InitializeResponseData, PlanRequestData, PlanResponseData, ResourceConfig, ValidateRequestData, ValidateResponseData } from 'codify-schemas';
-import { Plan } from './plan.js';
-import { Resource } from './resource.js';
-export declare class Plugin {
-    name: string;
-    resources: Map<string, Resource<ResourceConfig>>;
-    planStorage: Map<string, Plan<any>>;
-    static create(name: string, resources: Resource<any>[]): Plugin;
-    constructor(name: string, resources: Map<string, Resource<ResourceConfig>>);
-    initialize(): Promise<InitializeResponseData>;
-    validate(data: ValidateRequestData): Promise<ValidateResponseData>;
-    plan(data: PlanRequestData): Promise<PlanResponseData>;
-    apply(data: ApplyRequestData): Promise<void>;
-    private resolvePlan;
-    protected crossValidateResources(configs: ResourceConfig[]): Promise<void>;
-}