codify-plugin-lib 1.0.178 → 1.0.179

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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,152 @@
+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

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

package/dist/entities/errors.js

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

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

@@ -0,0 +1,25 @@
+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

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

package/dist/entities/plan.d.ts

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,127 @@
+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

@@ -0,0 +1,16 @@
+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>;
+}

package/dist/entities/plugin.js

@@ -0,0 +1,80 @@
+import { splitUserConfig } from '../utils/utils.js';
+import { Plan } from './plan.js';
+export class Plugin {
+    name;
+    resources;
+    planStorage;
+    static create(name, resources) {
+        const resourceMap = new Map(resources.map((r) => [r.typeId, r]));
+        return new Plugin(name, resourceMap);
+    }
+    constructor(name, resources) {
+        this.name = name;
+        this.resources = resources;
+        this.planStorage = new Map();
+    }
+    async initialize() {
+        for (const resource of this.resources.values()) {
+            await resource.onInitialize();
+        }
+        return {
+            resourceDefinitions: [...this.resources.values()]
+                .map((r) => ({
+                dependencies: r.dependencies,
+                type: r.typeId,
+            }))
+        };
+    }
+    async validate(data) {
+        const validationResults = [];
+        for (const config of data.configs) {
+            if (!this.resources.has(config.type)) {
+                throw new Error(`Resource type not found: ${config.type}`);
+            }
+            const { parameters, resourceMetadata } = splitUserConfig(config);
+            const validation = await this.resources
+                .get(config.type)
+                .validate(parameters, resourceMetadata);
+            validationResults.push(validation);
+        }
+        await this.crossValidateResources(data.configs);
+        return {
+            resourceValidations: validationResults
+        };
+    }
+    async plan(data) {
+        const type = data.desired?.type ?? data.state?.type;
+        if (!type || !this.resources.has(type)) {
+            throw new Error(`Resource type not found: ${type}`);
+        }
+        const plan = await this.resources.get(type).plan(data.desired ?? null, data.state ?? null, data.isStateful);
+        this.planStorage.set(plan.id, plan);
+        return plan.toResponse();
+    }
+    async apply(data) {
+        if (!data.planId && !data.plan) {
+            throw new Error('For applies either plan or planId must be supplied');
+        }
+        const plan = this.resolvePlan(data);
+        const resource = this.resources.get(plan.getResourceType());
+        if (!resource) {
+            throw new Error('Malformed plan with resource that cannot be found');
+        }
+        await resource.apply(plan);
+    }
+    resolvePlan(data) {
+        const { plan: planRequest, planId } = data;
+        if (planId) {
+            if (!this.planStorage.has(planId)) {
+                throw new Error(`Plan with id: ${planId} was not found`);
+            }
+            return this.planStorage.get(planId);
+        }
+        if (!planRequest?.resourceType || !this.resources.has(planRequest.resourceType)) {
+            throw new Error('Malformed plan. Resource type must be supplied or resource type was not found');
+        }
+        const resource = this.resources.get(planRequest.resourceType);
+        return Plan.fromResponse(planRequest, resource.defaultValues);
+    }
+    async crossValidateResources(configs) { }
+}

package/dist/entities/resource-options.d.ts

@@ -0,0 +1,31 @@
+import { StringIndexedObject } from 'codify-schemas';
+import { ParameterOptions } from './plan-types.js';
+import { ResourceParameterOptions } from './resource-types.js';
+import { StatefulParameter } from './stateful-parameter.js';
+import { TransformParameter } from './transform-parameter.js';
+export interface ResourceOptions<T extends StringIndexedObject> {
+    callStatefulParameterRemoveOnDestroy?: boolean;
+    dependencies?: string[];
+    parameterOptions?: Partial<Record<keyof T, ResourceParameterOptions | ResourceStatefulParameterOptions<T> | ResourceTransformParameterOptions<T>>>;
+    schema?: unknown;
+    type: string;
+}
+export interface ResourceStatefulParameterOptions<T extends StringIndexedObject> {
+    order?: number;
+    statefulParameter: StatefulParameter<T, T[keyof T]>;
+}
+export interface ResourceTransformParameterOptions<T extends StringIndexedObject> {
+    order?: number;
+    transformParameter: TransformParameter<T>;
+}
+export declare class ResourceOptionsParser<T extends StringIndexedObject> {
+    private options;
+    constructor(options: ResourceOptions<T>);
+    get statefulParameters(): Map<keyof T, StatefulParameter<T, T[keyof T]>>;
+    get transformParameters(): Map<keyof T, TransformParameter<T>>;
+    get resourceParameters(): Map<keyof T, ResourceParameterOptions>;
+    get changeSetParameterOptions(): Record<keyof T, ParameterOptions>;
+    get defaultValues(): Partial<Record<keyof T, unknown>>;
+    get statefulParameterOrder(): Map<keyof T, number>;
+    get transformParameterOrder(): Map<keyof T, number>;
+}

package/dist/entities/resource-options.js

@@ -0,0 +1,76 @@
+export class ResourceOptionsParser {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    get statefulParameters() {
+        const statefulParameters = Object.entries(this.options.parameterOptions ?? {})
+            .filter(([, p]) => p?.hasOwnProperty('statefulParameter'))
+            .map(([k, v]) => [k, v])
+            .map(([k, v]) => [k, v.statefulParameter]);
+        return new Map(statefulParameters);
+    }
+    get transformParameters() {
+        const transformParameters = Object.entries(this.options.parameterOptions ?? {})
+            .filter(([, p]) => p?.hasOwnProperty('transformParameter'))
+            .map(([k, v]) => [k, v])
+            .map(([k, v]) => [k, v.transformParameter]);
+        return new Map(transformParameters);
+    }
+    get resourceParameters() {
+        const resourceParameters = Object.entries(this.options.parameterOptions ?? {})
+            .filter(([, p]) => !(p?.hasOwnProperty('statefulParameter') || p?.hasOwnProperty('transformParameter')))
+            .map(([k, v]) => [k, v]);
+        return new Map(resourceParameters);
+    }
+    get changeSetParameterOptions() {
+        const resourceParameters = Object.fromEntries([...this.resourceParameters.entries()]
+            .map(([name, value]) => ([name, { ...value, isStatefulParameter: false }])));
+        const statefulParameters = [...this.statefulParameters.entries()]
+            ?.reduce((obj, sp) => ({
+            ...obj,
+            [sp[0]]: {
+                ...sp[1].options,
+                isStatefulParameter: true,
+            }
+        }), {});
+        return {
+            ...resourceParameters,
+            ...statefulParameters,
+        };
+    }
+    get defaultValues() {
+        if (!this.options.parameterOptions) {
+            return {};
+        }
+        return Object.fromEntries([...this.resourceParameters.entries()]
+            .filter(([, rp]) => rp.default !== undefined)
+            .map(([name, rp]) => [name, rp.default]));
+    }
+    get statefulParameterOrder() {
+        const entries = Object.entries(this.options.parameterOptions ?? {})
+            .filter(([, v]) => v?.hasOwnProperty('statefulParameter'))
+            .map(([k, v]) => [k, v]);
+        const orderedEntries = entries.filter(([, v]) => v.order !== undefined);
+        const unorderedEntries = entries.filter(([, v]) => v.order === undefined);
+        orderedEntries.sort((a, b) => a[1].order - b[1].order);
+        const resultArray = [
+            ...orderedEntries.map(([k]) => k),
+            ...unorderedEntries.map(([k]) => k)
+        ];
+        return new Map(resultArray.map((key, idx) => [key, idx]));
+    }
+    get transformParameterOrder() {
+        const entries = Object.entries(this.options.parameterOptions ?? {})
+            .filter(([, v]) => v?.hasOwnProperty('transformParameter'))
+            .map(([k, v]) => [k, v]);
+        const orderedEntries = entries.filter(([, v]) => v.order !== undefined);
+        const unorderedEntries = entries.filter(([, v]) => v.order === undefined);
+        orderedEntries.sort((a, b) => a[1].order - b[1].order);
+        const resultArray = [
+            ...orderedEntries.map(([k]) => k),
+            ...unorderedEntries.map(([k]) => k)
+        ];
+        return new Map(resultArray.map((key, idx) => [key, idx]));
+    }
+}

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

@@ -0,0 +1,11 @@
+export type ErrorMessage = string;
+export interface ResourceParameterOptions {
+    default?: unknown;
+    isEqual?: (desired: any, current: any) => boolean;
+    modifyOnChange?: boolean;
+}
+export interface ResourceDefinition {
+    [x: string]: {
+        type: string;
+    };
+}

package/dist/entities/resource-types.js

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

package/dist/entities/resource.d.ts

@@ -0,0 +1,42 @@
+import { Ajv, ValidateFunction } from 'ajv';
+import { ResourceConfig, StringIndexedObject, ValidateResponseData } from 'codify-schemas';
+import { ParameterChange } from './change-set.js';
+import { Plan } from './plan.js';
+import { CreatePlan, DestroyPlan, ModifyPlan, ParameterOptions } from './plan-types.js';
+import { ResourceOptions } from './resource-options.js';
+import { ResourceParameterOptions } from './resource-types.js';
+import { StatefulParameter } from './stateful-parameter.js';
+import { TransformParameter } from './transform-parameter.js';
+export declare abstract class Resource<T extends StringIndexedObject> {
+    readonly typeId: string;
+    readonly statefulParameters: Map<keyof T, StatefulParameter<T, T[keyof T]>>;
+    readonly transformParameters: Map<keyof T, TransformParameter<T>>;
+    readonly resourceParameters: Map<keyof T, ResourceParameterOptions>;
+    readonly statefulParameterOrder: Map<keyof T, number>;
+    readonly transformParameterOrder: Map<keyof T, number>;
+    readonly dependencies: string[];
+    readonly parameterOptions: Record<keyof T, ParameterOptions>;
+    readonly options: ResourceOptions<T>;
+    readonly defaultValues: Partial<Record<keyof T, unknown>>;
+    protected ajv?: Ajv;
+    protected schemaValidator?: ValidateFunction;
+    protected constructor(options: ResourceOptions<T>);
+    onInitialize(): Promise<void>;
+    validate(parameters: Partial<T>, resourceMetaData: ResourceConfig): Promise<ValidateResponseData['resourceValidations'][0]>;
+    plan(desiredConfig: Partial<T> & ResourceConfig | null, currentConfig?: Partial<T> & ResourceConfig | null, statefulMode?: boolean): Promise<Plan<T>>;
+    apply(plan: Plan<T>): Promise<void>;
+    private _applyCreate;
+    private _applyModify;
+    private _applyDestroy;
+    private validateRefreshResults;
+    private applyTransformParameters;
+    private addDefaultValues;
+    private refreshNonStatefulParameters;
+    private refreshStatefulParameters;
+    private validatePlanInputs;
+    customValidation(parameters: Partial<T>): Promise<void>;
+    abstract refresh(parameters: Partial<T>): Promise<Partial<T> | null>;
+    abstract applyCreate(plan: CreatePlan<T>): Promise<void>;
+    applyModify(pc: ParameterChange<T>, plan: ModifyPlan<T>): Promise<void>;
+    abstract applyDestroy(plan: DestroyPlan<T>): Promise<void>;
+}