@kinotic-ai/kinotic-cli 1.0.0

package/dist/internal/converter/IConversionContext.d.ts

@@ -0,0 +1,64 @@
+import { IConverterStrategy } from './IConverterStrategy.js';
+/**
+ * {@link IConversionContext} allows for conversion of a specific language type to Continuum IDL types.
+ * The {@link IConversionContext} contains state and can be reused but will retain state between requests.
+ * If state needs to be reset a new {@link IConversionContext} should be created.
+ *
+ * @param <BASE_TYPE> The base type that will be converted
+ * @param <S> The state type
+ *s
+ * Created by Navíd Mitchell 🤪 on 4/26/23.
+ */
+export interface IConversionContext<T, R, S> {
+    /**
+     * The current json path being processed.
+     * This is only updated if beginProcessingProperty and endProcessingProperty are called appropriately.
+     * This cannot be updated manually
+     */
+    actualJsonPath: string;
+    /**
+     * The property stack. This is only updated if beginProcessingProperty and endProcessingProperty are called appropriately.
+     * This cannot be updated manually
+     */
+    actualPropertyStack: string[];
+    /**
+     * The current json path being processed.
+     * This is only updated if beginProcessingProperty and endProcessingProperty are called appropriately.
+     * You should not update this manually unless you know what you are doing.
+     */
+    currentJsonPath: string;
+    /**
+     * The property stack. This is only updated if beginProcessingProperty and endProcessingProperty are called appropriately.
+     * You should not update this manually unless you know what you are doing.
+     */
+    propertyStack: string[];
+    /**
+     * Should be called before processing a property.
+     * This improves debug output
+     * @param name of the property
+     */
+    beginProcessingProperty(name: string): void;
+    /**
+     * Should be called after processing a property.
+     */
+    endProcessingProperty(): void;
+    /**
+     * Converts the given type to a {@link R} by resolving the proper {@link ITypeConverter}.
+     *
+     * @param value to convert
+     * @return the converted value
+     */
+    convert(value: T): R;
+    /**
+     * @return the state of this {@link IConversionContext}
+     */
+    state(): S;
+}
+/**
+ * Creates {@link IConversionContext} instances based on a {@link IConverterStrategy}
+ * The {@link IConversionContext} allows for conversion of a specific language type to Continuum IDL types.
+ * The {@link IConversionContext} contains state and can be reused but will retain state between requests.
+ * If state needs to be reset a new {@link IConversionContext} should be created.
+ * @param strategy
+ */
+export declare function createConversionContext<T, R, S>(strategy: IConverterStrategy<T, R, S>): IConversionContext<T, R, S>;

package/dist/internal/converter/IConversionContext.js

@@ -0,0 +1,11 @@
+import { DefaultConversionContext } from './DefaultConversionContext.js';
+/**
+ * Creates {@link IConversionContext} instances based on a {@link IConverterStrategy}
+ * The {@link IConversionContext} allows for conversion of a specific language type to Continuum IDL types.
+ * The {@link IConversionContext} contains state and can be reused but will retain state between requests.
+ * If state needs to be reset a new {@link IConversionContext} should be created.
+ * @param strategy
+ */
+export function createConversionContext(strategy) {
+    return new DefaultConversionContext(strategy);
+}

package/dist/internal/converter/IConverterStrategy.d.ts

@@ -0,0 +1,35 @@
+import { ITypeConverter } from './ITypeConverter.js';
+import { Logger } from '../Logger.js';
+/**
+ * The {@link IConverterStrategy} is used to determine how to convert a specific language type to a Continuum IDL.
+ * The {@link IConverterStrategy} should be reusable and thread safe.
+ *
+ * @param <BASE_TYPE> The base type to convert from
+ * @param <T> The type to convert to
+ * @param <S> The state type
+ *
+ * Created by Navíd Mitchell 🤪 on 4/26/23.
+ */
+export interface IConverterStrategy<T, R, S> {
+    /**
+     * An array of {@link ITypeConverter}'s that will be used to convert a specific language type.
+     */
+    typeConverters(): Array<ITypeConverter<T, R, S>>;
+    /**
+     * The object that will be available via the {@link IConversionContext#state()}.
+     * This can be a simple {@link Map} or something with better type safety.
+     * This can return a new instance each time it is called.
+     * This will be called each time a new {@link IConversionContext} is created.
+     * @return the conversion context state.
+     */
+    initialState(): S | (() => S);
+    /**
+     * Returns a logger that can be used to log messages.
+     */
+    logger(): Logger | (() => Logger);
+    /**
+     * Prints a value to a string.
+     * This is used in error messages to help the user understand what value caused the error.
+     */
+    valueToString(value: T): string;
+}

package/dist/internal/converter/IConverterStrategy.js

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

package/dist/internal/converter/ITypeConverter.d.ts

@@ -0,0 +1,28 @@
+import { IConversionContext } from './IConversionContext.js';
+/**
+ * {@link ITypeConverter} are the base interface for converting a specific type to another specific type.
+ * All {@link ITypeConverter}'s should be stateless. Any state that needs to be retained should be stored in the {@link IConversionContext}.
+ *
+ * @param <BASE_TYPE> the base type to convert from
+ * @param <T> the type to convert to
+ * @param <S> the state type
+ *
+ * Created by Navíd Mitchell 🤪 on 4/26/23.
+ */
+export interface ITypeConverter<T, R, S> {
+    /**
+     * Converts the given value to the specified return type.
+     * @param value to convert
+     * @param conversionContext the context to use for conversion
+     * @return the converted type
+     */
+    convert(value: T, conversionContext: IConversionContext<T, R, S>): R;
+    /**
+     * Checks if the given value is supported by this converter
+     *
+     * @param value to check if supported
+     * @param conversionState the state of the conversion, that is contained in the {@link IConversionContext}
+     * @return true if this converter can convert the type false if not
+     */
+    supports(value: T, conversionState: S): boolean;
+}

package/dist/internal/converter/ITypeConverter.js

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

package/dist/internal/converter/SpecificTypesConverter.d.ts

@@ -0,0 +1,12 @@
+import { ITypeConverter } from './ITypeConverter.js';
+import { IConversionContext } from './IConversionContext.js';
+/**
+ * {@link ITypeConverter} are the base interface for converting a specific type to another specific type.
+ */
+export declare abstract class SpecificTypesConverter<T, R, S, MATCH_VALUE> implements ITypeConverter<T, R, S> {
+    private readonly matchValueExtractor;
+    private typeConverterFunctions;
+    protected constructor(matchValueExtractor: (arg: T) => MATCH_VALUE, typeConverterFunctions: Map<MATCH_VALUE, ((type: T, context: IConversionContext<T, R, S>) => R)>);
+    convert(value: T, conversionContext: IConversionContext<T, R, S>): R;
+    supports(value: T): boolean;
+}

package/dist/internal/converter/SpecificTypesConverter.js

@@ -0,0 +1,24 @@
+/**
+ * {@link ITypeConverter} are the base interface for converting a specific type to another specific type.
+ */
+export class SpecificTypesConverter {
+    matchValueExtractor;
+    typeConverterFunctions;
+    constructor(matchValueExtractor, typeConverterFunctions) {
+        this.matchValueExtractor = matchValueExtractor;
+        this.typeConverterFunctions = typeConverterFunctions;
+    }
+    convert(value, conversionContext) {
+        const matchValue = this.matchValueExtractor(value);
+        const converterFunction = this.typeConverterFunctions.get(matchValue);
+        if (!converterFunction) {
+            // Should never happen due to supports call!
+            throw new Error("Converter function could not be resolved, WAT!");
+        }
+        return converterFunction(value, conversionContext);
+    }
+    supports(value) {
+        const matchValue = this.matchValueExtractor(value);
+        return this.typeConverterFunctions.has(matchValue);
+    }
+}

package/dist/internal/converter/codegen/ArrayC3TypeToStatementMapper.d.ts

@@ -0,0 +1,9 @@
+import { C3Type } from '@kinotic-ai/idl';
+import { ITypeConverter } from '../ITypeConverter.js';
+import { IConversionContext } from '../IConversionContext.js';
+import { StatementMapper } from './StatementMapper.js';
+import { StatementMapperConversionState } from './StatementMapperConversionState.js';
+export declare class ArrayC3TypeToStatementMapper implements ITypeConverter<C3Type, StatementMapper, StatementMapperConversionState> {
+    convert(value: C3Type, conversionContext: IConversionContext<C3Type, StatementMapper, StatementMapperConversionState>): StatementMapper;
+    supports(value: C3Type, conversionState: StatementMapperConversionState): boolean;
+}

package/dist/internal/converter/codegen/ArrayC3TypeToStatementMapper.js

@@ -0,0 +1,46 @@
+import { ArrayC3Type } from '@kinotic-ai/idl';
+import { MultiStatementMapper, } from './StatementMapper.js';
+import { camel } from 'radash';
+export class ArrayC3TypeToStatementMapper {
+    convert(value, conversionContext) {
+        const arrayC3Type = value;
+        const ret = new MultiStatementMapper(conversionContext.state());
+        const currentJsonPath = conversionContext.currentJsonPath;
+        const currentPropertyStack = conversionContext.propertyStack;
+        const targetName = conversionContext.state().targetName;
+        const sourceName = conversionContext.state().sourceName;
+        const targetJsonPath = targetName + (currentJsonPath.length > 0 ? '.' + currentJsonPath : '');
+        const sourceJsonPath = sourceName + (currentJsonPath.length > 0 ? '.' + currentJsonPath : '');
+        const itemName = camel(sourceJsonPath.replaceAll('.', ' ') + ' Item');
+        const internalTargetName = camel(targetJsonPath.replaceAll('.', ' ') + ' Value');
+        ret.addLiteral(`if (${sourceJsonPath}) {`);
+        conversionContext.state().indentMore();
+        ret.addLiteral(`${targetJsonPath} = []`);
+        ret.addLiteral(`for (let ${itemName} of ${sourceJsonPath}) {`);
+        conversionContext.state().indentMore();
+        ret.addLiteral(`let ${internalTargetName}: any`);
+        if (arrayC3Type.contains) {
+            conversionContext.state().targetName = internalTargetName;
+            conversionContext.state().sourceName = itemName;
+            conversionContext.currentJsonPath = '';
+            conversionContext.propertyStack = [];
+            ret.add(conversionContext.convert(arrayC3Type.contains));
+            conversionContext.currentJsonPath = currentJsonPath;
+            conversionContext.propertyStack = currentPropertyStack;
+            conversionContext.state().targetName = targetName;
+            conversionContext.state().sourceName = sourceName;
+        }
+        else {
+            throw new Error('ArrayC3Type.contains is undefined');
+        }
+        ret.addLiteral(`${targetJsonPath}.push(${internalTargetName})`);
+        conversionContext.state().indentLess();
+        ret.addLiteral('}');
+        conversionContext.state().indentLess();
+        ret.addLiteral('}');
+        return ret;
+    }
+    supports(value, conversionState) {
+        return value instanceof ArrayC3Type || value.type === 'array';
+    }
+}

package/dist/internal/converter/codegen/ObjectC3TypeToStatementMapper.d.ts

@@ -0,0 +1,13 @@
+import { C3Type } from '@kinotic-ai/idl';
+import { ITypeConverter } from '../ITypeConverter.js';
+import { IConversionContext } from '../IConversionContext.js';
+import { StatementMapper } from './StatementMapper.js';
+import { StatementMapperConversionState } from './StatementMapperConversionState.js';
+export declare class ObjectC3TypeToStatementMapper implements ITypeConverter<C3Type, StatementMapper, StatementMapperConversionState> {
+    convert(value: C3Type, conversionContext: IConversionContext<C3Type, StatementMapper, StatementMapperConversionState>): StatementMapper;
+    private createStatementForFunction;
+    private removeSourceFilePath;
+    private removeSourceFilePathFromObject;
+    private removeSourceFilePathFromUnion;
+    supports(value: C3Type, conversionState: StatementMapperConversionState): boolean;
+}

package/dist/internal/converter/codegen/ObjectC3TypeToStatementMapper.js

@@ -0,0 +1,67 @@
+import { ArrayC3Type, ObjectC3Type, UnionC3Type } from '@kinotic-ai/idl';
+import { MultiStatementMapper, LiteralStatementMapper } from './StatementMapper.js';
+export class ObjectC3TypeToStatementMapper {
+    convert(value, conversionContext) {
+        const state = conversionContext.state();
+        const objectC3Type = value;
+        const ret = new MultiStatementMapper(state);
+        const targetName = state.targetName;
+        const sourceName = state.sourceName;
+        const jsonPath = (conversionContext.currentJsonPath.length > 0 ? '.' + conversionContext.currentJsonPath : '');
+        const lhs = targetName + jsonPath;
+        const condition = sourceName + jsonPath;
+        ret.addLiteral('if (' + condition + ') {');
+        state.indentMore();
+        ret.add(new LiteralStatementMapper(`${lhs} = (${lhs} ? ${lhs} : {})`));
+        for (const property of objectC3Type.properties) {
+            conversionContext.beginProcessingProperty(property.name);
+            ret.add(conversionContext.convert(property.type));
+            conversionContext.endProcessingProperty();
+        }
+        state.indentLess();
+        ret.addLiteral('}');
+        if (value?.metadata?.sourceFilePath) {
+            delete value.metadata.sourceFilePath;
+        }
+        return ret;
+    }
+    createStatementForFunction(functionDeclaration, conversionContext) {
+        const targetName = conversionContext.state().targetName;
+        const lhs = targetName + (conversionContext.currentJsonPath.length > 0 ? '.' + conversionContext.currentJsonPath : '');
+        const functionName = functionDeclaration.getNameOrThrow('Could not find function name');
+        let ret = new LiteralStatementMapper(`${lhs} = ${functionName}(entity)`);
+        ret.neededImports.push({ importName: functionName,
+            sourcePath: functionDeclaration.getSourceFile().getFilePath(),
+            defaultExport: functionDeclaration.isDefaultExport() });
+        return ret;
+    }
+    removeSourceFilePath(value) {
+        if (value instanceof ObjectC3Type) {
+            this.removeSourceFilePathFromObject(value);
+        }
+        else if (value instanceof UnionC3Type) {
+            this.removeSourceFilePathFromUnion(value);
+        }
+        else if (value instanceof ArrayC3Type) {
+            this.removeSourceFilePath(value.contains);
+        }
+    }
+    removeSourceFilePathFromObject(value) {
+        const objectC3Type = value;
+        if (objectC3Type?.metadata?.sourceFilePath) {
+            delete objectC3Type.metadata.sourceFilePath;
+        }
+        for (const property of objectC3Type.properties) {
+            this.removeSourceFilePath(property.type);
+        }
+    }
+    removeSourceFilePathFromUnion(value) {
+        const unionC3Type = value;
+        for (const type of unionC3Type.types) {
+            this.removeSourceFilePath(type);
+        }
+    }
+    supports(value, conversionState) {
+        return value instanceof ObjectC3Type || value.type === 'object';
+    }
+}

package/dist/internal/converter/codegen/PrimitiveC3TypeToStatementMapper.d.ts

@@ -0,0 +1,9 @@
+import { C3Type } from '@kinotic-ai/idl';
+import { IConversionContext } from '../IConversionContext.js';
+import { ITypeConverter } from '../ITypeConverter.js';
+import { StatementMapper } from './StatementMapper.js';
+import { StatementMapperConversionState } from './StatementMapperConversionState.js';
+export declare class PrimitiveC3TypeToStatementMapper implements ITypeConverter<C3Type, StatementMapper, StatementMapperConversionState> {
+    convert(value: C3Type, conversionContext: IConversionContext<C3Type, StatementMapper, StatementMapperConversionState>): StatementMapper;
+    supports(value: C3Type, conversionState: StatementMapperConversionState): boolean;
+}

package/dist/internal/converter/codegen/PrimitiveC3TypeToStatementMapper.js

@@ -0,0 +1,24 @@
+import { BooleanC3Type, ByteC3Type, CharC3Type, DateC3Type, DoubleC3Type, EnumC3Type, FloatC3Type, IntC3Type, LongC3Type, ShortC3Type, StringC3Type } from '@kinotic-ai/idl';
+import { LiteralStatementMapper } from './StatementMapper.js';
+export class PrimitiveC3TypeToStatementMapper {
+    convert(value, conversionContext) {
+        const targetName = conversionContext.state().targetName;
+        const sourceName = conversionContext.state().sourceName;
+        const lhs = targetName + (conversionContext.currentJsonPath.length > 0 ? '.' + conversionContext.currentJsonPath : '');
+        const rhs = sourceName + (conversionContext.currentJsonPath.length > 0 ? '.' + conversionContext.currentJsonPath : '');
+        return new LiteralStatementMapper(`${lhs} = ${rhs}`);
+    }
+    supports(value, conversionState) {
+        return (value instanceof BooleanC3Type || value.type === 'boolean')
+            || (value instanceof ByteC3Type || value.type === 'byte')
+            || (value instanceof CharC3Type || value.type === 'char')
+            || (value instanceof DateC3Type || value.type === 'date')
+            || (value instanceof DoubleC3Type || value.type === 'double')
+            || (value instanceof EnumC3Type || value.type === 'enum')
+            || (value instanceof FloatC3Type || value.type === 'float')
+            || (value instanceof IntC3Type || value.type === 'int')
+            || (value instanceof LongC3Type || value.type === 'long')
+            || (value instanceof ShortC3Type || value.type === 'short')
+            || (value instanceof StringC3Type || value.type === 'string');
+    }
+}

package/dist/internal/converter/codegen/StatementMapper.d.ts

@@ -0,0 +1,40 @@
+import { StatementMapperConversionState } from './StatementMapperConversionState.js';
+export interface NeededImport {
+    importName: string;
+    defaultExport?: boolean;
+    sourcePath: string;
+}
+export interface StatementMapper {
+    getNeededImports(): NeededImport[];
+    toStatementString(): string | null;
+}
+export declare class MultiStatementMapper implements StatementMapper {
+    private readonly _state;
+    private readonly _mappers;
+    constructor(state: StatementMapperConversionState, mappers?: Array<StatementMapper>);
+    add(mapper: StatementMapper): MultiStatementMapper;
+    addLiteral(stringLiteral: string): MultiStatementMapper;
+    getNeededImports(): NeededImport[];
+    toStatementString(): string | null;
+}
+export declare class IndentingStatementMapper implements StatementMapper {
+    private readonly _indent;
+    private readonly _mapper;
+    constructor(indent: number, mapper: StatementMapper);
+    getNeededImports(): NeededImport[];
+    toStatementString(): string | null;
+}
+export declare class LiteralStatementMapper implements StatementMapper {
+    statementString: string | null;
+    neededImports: NeededImport[];
+    constructor(statementString?: string | null, neededImports?: NeededImport[]);
+    getNeededImports(): NeededImport[];
+    toStatementString(): string | null;
+}
+/**
+ * Creates a string that can be used to import all the needed imports for a file.
+ * @param statementMapper The statement mapper that contains the needed imports.
+ * @param targetFilePath The path to the file that will be generated.
+ * @param fileExtensionForImports The file extension to use for imports.
+ */
+export declare function createImportString(statementMapper: StatementMapper | null, targetFilePath: string, fileExtensionForImports: string): string | null;

package/dist/internal/converter/codegen/StatementMapper.js

@@ -0,0 +1,132 @@
+import { getRelativeImportPath, tryGetNodeModuleName } from '../../Utils.js';
+export class MultiStatementMapper {
+    _state;
+    _mappers;
+    constructor(state, mappers) {
+        this._state = state;
+        this._mappers = mappers || [];
+    }
+    add(mapper) {
+        if (mapper instanceof MultiStatementMapper) {
+            this._mappers.push(mapper);
+        }
+        else {
+            this._mappers.push(new IndentingStatementMapper(this._state.indent, mapper));
+        }
+        return this;
+    }
+    addLiteral(stringLiteral) {
+        this.add(new LiteralStatementMapper(stringLiteral));
+        return this;
+    }
+    getNeededImports() {
+        return this._mappers.map(mapper => mapper.getNeededImports()).flat();
+    }
+    toStatementString() {
+        let ret = null;
+        for (const mapper of this._mappers) {
+            const statementString = mapper.toStatementString();
+            if (statementString != null) {
+                if (ret == null) {
+                    ret = '';
+                }
+                ret += statementString + (statementString.endsWith('\n') ? '' : '\n');
+            }
+        }
+        return ret;
+    }
+}
+export class IndentingStatementMapper {
+    _indent;
+    _mapper;
+    constructor(indent, mapper) {
+        this._indent = indent;
+        this._mapper = mapper;
+    }
+    getNeededImports() {
+        return this._mapper.getNeededImports();
+    }
+    toStatementString() {
+        const out = this._mapper.toStatementString();
+        return ' '.repeat(this._indent) + out;
+    }
+}
+export class LiteralStatementMapper {
+    statementString = null;
+    neededImports = [];
+    constructor(statementString, neededImports) {
+        if (statementString) {
+            this.statementString = statementString;
+        }
+        if (neededImports) {
+            this.neededImports = neededImports;
+        }
+    }
+    getNeededImports() {
+        return this.neededImports;
+    }
+    toStatementString() {
+        return this.statementString;
+    }
+}
+/**
+ * Creates a string that can be used to import all the needed imports for a file.
+ * @param statementMapper The statement mapper that contains the needed imports.
+ * @param targetFilePath The path to the file that will be generated.
+ * @param fileExtensionForImports The file extension to use for imports.
+ */
+export function createImportString(statementMapper, targetFilePath, fileExtensionForImports) {
+    const importsWithoutDuplicates = statementMapper != null ? removeDuplicateImports(statementMapper.getNeededImports()) : [];
+    // Now make sure all imports for the same paths are grouped together in the import string
+    const importMap = {};
+    for (const imp of importsWithoutDuplicates) {
+        if (importMap[imp.sourcePath]) {
+            importMap[imp.sourcePath].push(imp);
+        }
+        else {
+            importMap[imp.sourcePath] = [imp];
+        }
+    }
+    let importString = '';
+    for (let importPath of Object.keys(importMap)) {
+        const imports = importMap[importPath];
+        // modify the source path to be correct for the target file
+        let newImportPath = tryGetNodeModuleName(importPath);
+        if (!newImportPath) {
+            newImportPath = getRelativeImportPath(targetFilePath, importPath, fileExtensionForImports);
+        }
+        importPath = newImportPath;
+        const defaultImports = imports.filter(imp => imp.defaultExport);
+        const namedImports = imports.filter(imp => !imp.defaultExport);
+        if (defaultImports.length > 0) {
+            if (defaultImports.length > 1) {
+                throw new Error(`Multiple default exports for import path ${importPath}`);
+            }
+            importString += `import ${defaultImports[0].importName} from '${importPath}'\n`;
+        }
+        if (namedImports.length > 0) {
+            importString += `import {${namedImports.map(imp => imp.importName).join(',\n')}} from '${importPath}'\n`;
+        }
+    }
+    return importString.length > 0 ? importString : null;
+}
+function removeDuplicateImports(imports) {
+    const ret = [];
+    const importMap = {};
+    for (const imp of imports) {
+        if (importMap[imp.importName]) {
+            const existing = importMap[imp.importName];
+            if (existing.sourcePath !== imp.sourcePath) {
+                throw new Error(`Import name ${imp.importName} is used for multiple imports with different paths: ${existing.sourcePath} and ${imp.sourcePath}`);
+            }
+            if (imp.defaultExport) {
+                importMap[imp.importName].defaultExport = true;
+            }
+        }
+        else {
+            importMap[imp.importName] = imp;
+            ret.push(imp);
+        }
+    }
+    return ret;
+}

package/dist/internal/converter/codegen/StatementMapperConversionState.d.ts

@@ -0,0 +1,9 @@
+import { BaseConversionState } from '../common/BaseConversionState.js';
+export declare class StatementMapperConversionState extends BaseConversionState {
+    sourceName: string;
+    targetName: string;
+    indent: number;
+    constructor(application: string);
+    indentMore(): StatementMapperConversionState;
+    indentLess(): StatementMapperConversionState;
+}

package/dist/internal/converter/codegen/StatementMapperConversionState.js

@@ -0,0 +1,17 @@
+import { BaseConversionState } from '../common/BaseConversionState.js';
+export class StatementMapperConversionState extends BaseConversionState {
+    sourceName = 'entity';
+    targetName = 'ret';
+    indent = 4;
+    constructor(application) {
+        super(application);
+    }
+    indentMore() {
+        this.indent += 2;
+        return this;
+    }
+    indentLess() {
+        this.indent -= 2;
+        return this;
+    }
+}

package/dist/internal/converter/codegen/StatementMapperConverterStrategy.d.ts

@@ -0,0 +1,16 @@
+import { C3Type } from '@kinotic-ai/idl';
+import { Logger } from '../../Logger.js';
+import { IConverterStrategy } from '../IConverterStrategy.js';
+import { ITypeConverter } from '../ITypeConverter.js';
+import { StatementMapper } from './StatementMapper.js';
+import { StatementMapperConversionState } from './StatementMapperConversionState.js';
+export declare class StatementMapperConverterStrategy implements IConverterStrategy<C3Type, StatementMapper, StatementMapperConversionState> {
+    private readonly _initialState;
+    private readonly _logger;
+    private readonly _typeConverters;
+    constructor(initialState: (() => StatementMapperConversionState) | StatementMapperConversionState, logger: Logger);
+    initialState(): (() => StatementMapperConversionState) | StatementMapperConversionState;
+    logger(): Logger | (() => Logger);
+    typeConverters(): Array<ITypeConverter<C3Type, StatementMapper, StatementMapperConversionState>>;
+    valueToString(value: C3Type): string;
+}

package/dist/internal/converter/codegen/StatementMapperConverterStrategy.js

@@ -0,0 +1,30 @@
+import { ArrayC3TypeToStatementMapper } from './ArrayC3TypeToStatementMapper.js';
+import { ObjectC3TypeToStatementMapper } from './ObjectC3TypeToStatementMapper.js';
+import { PrimitiveC3TypeToStatementMapper } from './PrimitiveC3TypeToStatementMapper.js';
+import { UnionC3TypeToStatementMapper } from './UnionC3TypeToStatementMapper.js';
+export class StatementMapperConverterStrategy {
+    _initialState;
+    _logger;
+    _typeConverters = [
+        new PrimitiveC3TypeToStatementMapper(),
+        new ArrayC3TypeToStatementMapper(),
+        new ObjectC3TypeToStatementMapper(),
+        new UnionC3TypeToStatementMapper()
+    ];
+    constructor(initialState, logger) {
+        this._initialState = initialState;
+        this._logger = logger;
+    }
+    initialState() {
+        return this._initialState;
+    }
+    logger() {
+        return this._logger;
+    }
+    typeConverters() {
+        return this._typeConverters;
+    }
+    valueToString(value) {
+        return value.type;
+    }
+}

package/dist/internal/converter/codegen/UnionC3TypeToStatementMapper.d.ts

@@ -0,0 +1,9 @@
+import { C3Type } from '@kinotic-ai/idl';
+import { ITypeConverter } from '../ITypeConverter.js';
+import { IConversionContext } from '../IConversionContext.js';
+import { StatementMapper } from './StatementMapper.js';
+import { StatementMapperConversionState } from './StatementMapperConversionState.js';
+export declare class UnionC3TypeToStatementMapper implements ITypeConverter<C3Type, StatementMapper, StatementMapperConversionState> {
+    convert(value: C3Type, conversionContext: IConversionContext<C3Type, StatementMapper, StatementMapperConversionState>): StatementMapper;
+    supports(value: C3Type, conversionState: StatementMapperConversionState): boolean;
+}