@kinotic-ai/kinotic-cli 1.0.0

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

@@ -0,0 +1,46 @@
+import { UnionC3Type } from '@kinotic-ai/idl';
+import { ConverterConstants } from '../ConverterConstants.js';
+import { MultiStatementMapper, LiteralStatementMapper } from './StatementMapper.js';
+import { camel } from 'radash';
+export class UnionC3TypeToStatementMapper {
+    convert(value, conversionContext) {
+        const unionC3Type = value;
+        const ret = new MultiStatementMapper(conversionContext.state());
+        const state = conversionContext.state();
+        const originalJsonPath = conversionContext.currentJsonPath;
+        const originalPropertyStack = conversionContext.propertyStack;
+        const originalTargetName = state.targetName;
+        const originalSourceName = state.sourceName;
+        const targetJsonPath = originalTargetName + (originalJsonPath.length > 0 ? '.' + originalJsonPath : '');
+        const sourceJsonPath = originalSourceName + (originalJsonPath.length > 0 ? '.' + originalJsonPath : '');
+        conversionContext.currentJsonPath = '';
+        conversionContext.propertyStack = [];
+        // to map the union type we merge all the properties into a single object
+        let counter = 1;
+        for (let objectC3Type of unionC3Type.types) {
+            const targetVariableName = camel(targetJsonPath.replaceAll('.', ' ') + `O${counter}`);
+            const sourceVariableName = camel(sourceJsonPath.replaceAll('.', ' ') + ` I${counter}`);
+            const castStatement = new LiteralStatementMapper(`let ${sourceVariableName} = ${sourceJsonPath} as ${objectC3Type.name}`);
+            if (objectC3Type.metadata) {
+                const sourcePath = objectC3Type.metadata[ConverterConstants.SOURCE_FILE_PATH];
+                castStatement.neededImports.push({ sourcePath: sourcePath, importName: objectC3Type.name });
+            }
+            ret.add(castStatement);
+            ret.add(new LiteralStatementMapper(`let ${targetVariableName} = ${targetJsonPath}`));
+            state.targetName = targetVariableName;
+            state.sourceName = sourceVariableName;
+            ret.add(conversionContext.convert(objectC3Type));
+            // assign back in case convert had side effects that were lost
+            ret.add(new LiteralStatementMapper(`${targetJsonPath} = ${targetVariableName}`));
+            counter++;
+        }
+        conversionContext.currentJsonPath = originalJsonPath;
+        conversionContext.propertyStack = originalPropertyStack;
+        state.targetName = originalTargetName;
+        state.sourceName = originalSourceName;
+        return ret;
+    }
+    supports(value, conversionState) {
+        return value instanceof UnionC3Type || value.type === 'union';
+    }
+}

package/dist/internal/converter/common/BaseConversionState.d.ts

@@ -0,0 +1,9 @@
+export declare class BaseConversionState {
+    private readonly _application;
+    /**
+     * Create a new instance of the BaseConversionState
+     * @param application the application that entities will belong to
+     */
+    constructor(application: string);
+    get application(): string;
+}

package/dist/internal/converter/common/BaseConversionState.js

@@ -0,0 +1,13 @@
+export class BaseConversionState {
+    _application;
+    /**
+     * Create a new instance of the BaseConversionState
+     * @param application the application that entities will belong to
+     */
+    constructor(application) {
+        this._application = application;
+    }
+    get application() {
+        return this._application;
+    }
+}

package/dist/internal/converter/typescript/ArrayToC3Type.d.ts

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

package/dist/internal/converter/typescript/ArrayToC3Type.js

@@ -0,0 +1,17 @@
+import { ArrayC3Type } from '@kinotic-ai/idl';
+export class ArrayToC3Type {
+    convert(value, conversionContext) {
+        let ret;
+        const arrayElementType = value?.getArrayElementType();
+        if (arrayElementType) {
+            ret = new ArrayC3Type(conversionContext.convert(arrayElementType));
+        }
+        else {
+            throw new Error("Type could not be found for array type " + value.getText());
+        }
+        return ret;
+    }
+    supports(value, conversionState) {
+        return value.isArray();
+    }
+}

package/dist/internal/converter/typescript/ConverterUtils.d.ts

@@ -0,0 +1,4 @@
+import { C3Decorator, C3Type } from '@kinotic-ai/idl';
+import { Decorator } from 'ts-morph';
+export declare function tsDecoratorToC3Decorator(decorator: Decorator): C3Decorator | null;
+export declare function convertPrecisionToC3Type(decorator: Decorator): C3Type;

package/dist/internal/converter/typescript/ConverterUtils.js

@@ -0,0 +1,261 @@
+import { DoubleC3Type, FloatC3Type, IntC3Type, LongC3Type, NotNullDecorator, ShortC3Type } from '@kinotic-ai/idl';
+import { AutoGeneratedIdDecorator, DiscriminatorDecorator, EntityDecorator, FlattenedDecorator, IdDecorator, NestedDecorator, NotIndexedDecorator, QueryDecorator, TenantIdDecorator, TextDecorator, TimeReferenceDecorator, VersionDecorator } from '@kinotic-ai/os-api';
+import { EntityType, MultiTenancyType } from '@kinotic-ai/persistence';
+import { SyntaxKind } from 'ts-morph';
+export function tsDecoratorToC3Decorator(decorator) {
+    let ret = null;
+    if (decorator.getName() === 'AutoGeneratedId') {
+        ret = new AutoGeneratedIdDecorator();
+    }
+    else if (decorator.getName() === 'Discriminator') {
+        const discriminatorDecorator = new DiscriminatorDecorator();
+        if (decorator.getArguments().length == 1) {
+            const argument = decorator.getArguments()[0];
+            if (argument?.getType()?.getLiteralValue()) {
+                discriminatorDecorator.propertyName = argument.getType().getLiteralValue();
+            }
+            else {
+                throw new Error('propertyName must be a string literal');
+            }
+        }
+        else {
+            throw new Error('propertyName must be set on Discriminator Decorator');
+        }
+        ret = discriminatorDecorator;
+    }
+    else if (decorator.getName() === 'Entity') {
+        const entityDecorator = new EntityDecorator();
+        if (decorator.getArguments().length > 0) {
+            const argument = decorator.getArguments()[0];
+            if (argument?.getText() == 'MultiTenancyType.SHARED') {
+                entityDecorator.multiTenancyType = MultiTenancyType.SHARED;
+            }
+            else if (argument?.getText() == 'MultiTenancyType.NONE') {
+                entityDecorator.multiTenancyType = MultiTenancyType.NONE;
+            }
+            else {
+                throw new Error(`Unsupported MultiTenancyType ${argument?.getText()}`);
+            }
+            if (decorator.getArguments().length == 2) {
+                const entityTypeArg = decorator.getArguments()[1];
+                if (entityTypeArg?.getText() == 'EntityType.TABLE') {
+                    entityDecorator.entityType = EntityType.TABLE;
+                }
+                else if (entityTypeArg?.getText() == 'EntityType.STREAM') {
+                    entityDecorator.entityType = EntityType.STREAM;
+                }
+                else {
+                    throw new Error(`Unsupported EntityType ${entityTypeArg?.getText()}`);
+                }
+            }
+        }
+        ret = entityDecorator;
+    }
+    else if (decorator.getName() === 'EntityServiceDecorators') {
+        const argument = decorator.getArguments()[0];
+        if (argument?.getKind() === SyntaxKind.ObjectLiteralExpression) {
+            const obj = convertToObjectLiteral(argument);
+            ret = {
+                type: 'EntityServiceDecorators',
+                config: obj,
+            };
+        }
+        else {
+            throw new Error('EntityServiceDecorators must have an object literal argument');
+        }
+    }
+    else if (decorator.getName() === 'EsIndexConfiguration') {
+        const argument = decorator.getArguments()[0];
+        if (argument?.getKind() === SyntaxKind.ObjectLiteralExpression) {
+            const obj = convertToObjectLiteral(argument);
+            ret = {
+                type: 'EsIndexConfigurationDecorator',
+                value: obj,
+            };
+        }
+        else {
+            throw new Error('EsIndexConfiguration must have an object literal argument');
+        }
+    }
+    else if (decorator.getName() === 'Flattened') {
+        ret = new FlattenedDecorator();
+    }
+    else if (decorator.getName() === 'Id') {
+        ret = new IdDecorator();
+    }
+    else if (decorator.getName() === 'Nested') {
+        ret = new NestedDecorator();
+    }
+    else if (decorator.getName() === 'NotIndexed') {
+        ret = new NotIndexedDecorator();
+    }
+    else if (decorator.getName() === 'NotNull') {
+        ret = new NotNullDecorator();
+    }
+    else if (decorator.getName() === 'Policy') {
+        const argument = decorator.getArguments()[0];
+        if (argument?.getKind() === SyntaxKind.ArrayLiteralExpression) {
+            const obj = parseExpressionToJs(argument);
+            ret = {
+                type: 'PolicyDecorator',
+                policies: obj,
+            };
+        }
+        else {
+            throw new Error('Policy must have an array literal argument');
+        }
+    }
+    else if (decorator.getName() === 'Query') {
+        if (decorator.getArguments().length == 1) {
+            const argument = decorator.getArguments()[0];
+            if (argument?.getType()?.getLiteralValue()) {
+                ret = new QueryDecorator(argument.getType().getLiteralValue());
+            }
+            else {
+                throw new Error('statement must be set on Query Decorator');
+            }
+        }
+    }
+    else if (decorator.getName() === 'Role') {
+        const argument = decorator.getArguments()[0];
+        if (argument?.getKind() === SyntaxKind.ArrayLiteralExpression) {
+            const obj = parseExpressionToJs(argument);
+            ret = {
+                type: 'RoleDecorator',
+                roles: obj,
+            };
+        }
+        else {
+            throw new Error('Role must have an array literal argument');
+        }
+    }
+    else if (decorator.getName() === 'TenantId') {
+        ret = new TenantIdDecorator();
+    }
+    else if (decorator.getName() === 'Text') {
+        ret = new TextDecorator();
+    }
+    else if (decorator.getName() === 'TimeReference') {
+        ret = new TimeReferenceDecorator();
+    }
+    else if (decorator.getName() === 'Version') {
+        ret = new VersionDecorator();
+    }
+    return ret;
+}
+export function convertPrecisionToC3Type(decorator) {
+    let ret;
+    if (decorator.getName() === 'Precision') {
+        if (decorator.getArguments().length == 1) {
+            const argument = decorator.getArguments()[0];
+            if (argument?.getText() == 'PrecisionType.DOUBLE') {
+                ret = new DoubleC3Type();
+            }
+            else if (argument?.getText() == 'PrecisionType.FLOAT') {
+                ret = new FloatC3Type();
+            }
+            else if (argument?.getText() == 'PrecisionType.INT') {
+                ret = new IntC3Type();
+            }
+            else if (argument?.getText() == 'PrecisionType.LONG') {
+                ret = new LongC3Type();
+            }
+            else if (argument?.getText() == 'PrecisionType.SHORT') {
+                ret = new ShortC3Type();
+            }
+            else {
+                throw new Error(`Unsupported PrecisionType ${argument?.getText()}`);
+            }
+        }
+        else {
+            ret = new IntC3Type();
+        }
+        return ret;
+    }
+    else {
+        throw new Error('Decorator is not Precision decorator');
+    }
+}
+function parseExpressionToJs(expression) {
+    switch (expression.getKind()) {
+        case SyntaxKind.AsExpression:
+            // Directly handle the expression part of the AsExpression
+            const asExpr = expression.asKindOrThrow(SyntaxKind.AsExpression);
+            return parseExpressionToJs(asExpr.getExpression());
+        case SyntaxKind.ObjectLiteralExpression:
+            return convertToObjectLiteral(expression);
+        case SyntaxKind.ArrayLiteralExpression:
+            return expression.asKindOrThrow(SyntaxKind.ArrayLiteralExpression)
+                .getElements()
+                .map((el) => parseExpressionToJs(el));
+        case SyntaxKind.StringLiteral:
+            return expression.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue();
+        case SyntaxKind.NumericLiteral:
+            return parseFloat(expression.asKindOrThrow(SyntaxKind.NumericLiteral).getLiteralText());
+        case SyntaxKind.TrueKeyword:
+            return true;
+        case SyntaxKind.FalseKeyword:
+            return false;
+        case SyntaxKind.CallExpression:
+            const callExpr = expression.asKindOrThrow(SyntaxKind.CallExpression);
+            if (callExpr.getText().startsWith('$')) { // Check if it is a supported internal function
+                return convertCallExpressionToJs(callExpr);
+            }
+            else {
+                throw new Error(`Unsupported call expression: ${callExpr.getText()}`);
+            }
+        default:
+            throw new Error(`Unsupported expression kind: ${expression.getKindName()} text: ${expression.getText()}`);
+    }
+}
+function convertCallExpressionToJs(expression) {
+    const text = expression.getText();
+    if (text.startsWith('$Policy')) {
+        if (expression.getArguments().length === 1) {
+            const argument = expression.getArguments()[0];
+            const obj = parseExpressionToJs(argument);
+            // Validate the parsed object structure
+            if (!Array.isArray(obj) || !obj.every(arr => Array.isArray(arr) && arr.every(item => typeof item === 'string'))) {
+                throw new Error('Policy must contain an array of string arrays (string[][])');
+            }
+            return {
+                type: 'PolicyDecorator',
+                policies: obj, // Fixed type assertion
+            };
+        }
+        else {
+            throw new Error('Policy must have an array literal argument');
+        }
+    }
+    else if (text.startsWith('$Role')) {
+        if (expression.getArguments().length == 1) {
+            const argument = expression.getArguments()[0];
+            const obj = parseExpressionToJs(argument);
+            return {
+                type: 'RoleDecorator',
+                roles: obj,
+            };
+        }
+        else {
+            throw new Error('Role must have an array literal argument');
+        }
+    }
+    else {
+        throw new Error(`Unsupported call expression: ${text}`);
+    }
+}
+// Convert ObjectLiteralExpression to a JavaScript object
+function convertToObjectLiteral(expression) {
+    const result = {};
+    for (const prop of expression.getProperties()) {
+        if (prop.getKind() === SyntaxKind.PropertyAssignment) {
+            const assignment = prop.asKindOrThrow(SyntaxKind.PropertyAssignment);
+            const key = assignment.getName();
+            const initializer = assignment.getInitializer();
+            if (initializer) {
+                result[key] = parseExpressionToJs(initializer);
+            }
+        }
+    }
+    return result;
+}

package/dist/internal/converter/typescript/EnumToC3Type.d.ts

@@ -0,0 +1,12 @@
+import { Type } from 'ts-morph';
+import { C3Type } from '@kinotic-ai/idl';
+import { TypescriptConversionState } from './TypescriptConversionState.js';
+import { IConversionContext } from '../IConversionContext.js';
+import { ITypeConverter } from '../ITypeConverter.js';
+/**
+ * Converts a typescript enum to a C3 Enum
+ */
+export declare class EnumToC3Type implements ITypeConverter<Type, C3Type, TypescriptConversionState> {
+    convert(value: Type, conversionContext: IConversionContext<Type, C3Type, TypescriptConversionState>): C3Type;
+    supports(value: Type, conversionState: TypescriptConversionState): boolean;
+}

package/dist/internal/converter/typescript/EnumToC3Type.js

@@ -0,0 +1,26 @@
+import { EnumC3Type } from '@kinotic-ai/idl';
+/**
+ * Converts a typescript enum to a C3 Enum
+ */
+export class EnumToC3Type {
+    convert(value, conversionContext) {
+        let ret;
+        const name = value.getSymbolOrThrow("No Symbol could be found for object: " + value.getText()).getName();
+        const namespace = conversionContext.state().application;
+        ret = new EnumC3Type(name, namespace);
+        // this is a little strange, but it is the easiest way to get the name of the enum
+        value.getUnionTypes().forEach((unionType) => {
+            const name = unionType?.getSymbol()?.getName();
+            if (name) {
+                ret.addValue(name);
+            }
+            else {
+                throw new Error("Could not find name for enum: " + value.getText());
+            }
+        });
+        return ret;
+    }
+    supports(value, conversionState) {
+        return value.isEnum();
+    }
+}

package/dist/internal/converter/typescript/ObjectLikeToC3Type.d.ts

@@ -0,0 +1,15 @@
+import { Type } from 'ts-morph';
+import { C3Type } from '@kinotic-ai/idl';
+import { TypescriptConversionState } from './TypescriptConversionState.js';
+import { IConversionContext } from '../IConversionContext.js';
+import { ITypeConverter } from '../ITypeConverter.js';
+/**
+ * Converts a typescript Class, Interface, or Type to a C3Type
+ */
+export declare class ObjectLikeToC3Type implements ITypeConverter<Type, C3Type, TypescriptConversionState> {
+    convert(value: Type, conversionContext: IConversionContext<Type, C3Type, TypescriptConversionState>): C3Type;
+    supports(value: Type): boolean;
+    private convertDecorators;
+    private convertProperties;
+    private convertProperty;
+}

package/dist/internal/converter/typescript/ObjectLikeToC3Type.js

@@ -0,0 +1,111 @@
+import { ObjectC3Type, PropertyDefinition } from '@kinotic-ai/idl';
+import { ConverterConstants } from '../ConverterConstants.js';
+import { tsDecoratorToC3Decorator, convertPrecisionToC3Type } from './ConverterUtils.js';
+import { TenantIdDecorator } from '@kinotic-ai/os-api';
+/**
+ * Converts a typescript Class, Interface, or Type to a C3Type
+ */
+export class ObjectLikeToC3Type {
+    convert(value, conversionContext) {
+        let ret;
+        const name = value.getSymbolOrThrow("No Symbol could be found for object: " + value.getText()).getName();
+        const namespace = conversionContext.state().application;
+        ret = new ObjectC3Type(name, namespace);
+        // Object stack name is used to help name properties that are not defined such as with union literals
+        conversionContext.state().objectNameStack.push(name);
+        // We store the original source path so, it can be used later
+        const declarations = value.getSymbol()?.getDeclarations();
+        if (conversionContext.state().shouldAddSourcePathToMetadata
+            && declarations
+            && declarations.length > 0) {
+            if (!ret.metadata) {
+                ret.metadata = {};
+            }
+            ret.metadata[ConverterConstants.SOURCE_FILE_PATH] = declarations[0].getSourceFile().getFilePath();
+        }
+        // Get value declaration so we can get the decorators
+        this.convertDecorators(value, ret);
+        // Translate all the typescript properties
+        this.convertProperties(value, conversionContext, ret);
+        conversionContext.state().objectNameStack.pop();
+        return ret;
+    }
+    supports(value) {
+        return value.isObject() && !value.isArray();
+    }
+    convertDecorators(value, ret) {
+        const errText = "No value declaration could be found for object " + value.getText();
+        const valueDeclaration = value.getSymbolOrThrow(errText)
+            .getValueDeclarationOrThrow(errText);
+        // Typescript cannot detect that this can be a DecoratableNode, so we have to cast it twice
+        const decoratableNode = valueDeclaration;
+        // Now Add any class level decorators
+        const decorators = decoratableNode.getDecorators();
+        if (decorators) {
+            for (const decorator of decorators) {
+                const c3Decorator = tsDecoratorToC3Decorator(decorator);
+                if (c3Decorator) {
+                    ret.addDecorator(c3Decorator);
+                }
+            }
+        }
+    }
+    convertProperties(value, conversionContext, ret) {
+        const properties = value.getProperties();
+        for (const property of properties) {
+            const propertyName = property.getName();
+            conversionContext.beginProcessingProperty(propertyName);
+            let propertyDefinition = this.convertProperty(property, propertyName, conversionContext);
+            ret.addPropertyDefinition(propertyDefinition);
+            conversionContext.endProcessingProperty();
+        }
+    }
+    convertProperty(property, propertyName, conversionContext) {
+        const valueDeclaration = property.getValueDeclarationOrThrow("No value declaration could be found for property " + propertyName);
+        let propertyDefinition;
+        if (valueDeclaration.getType().isUnion()) {
+            conversionContext.state().unionPropertyNameStack.push(propertyName);
+        }
+        // Typescript cannot detect that this can be a DecoratableNode, so we have to cast it twice
+        const decoratableNode = valueDeclaration;
+        if (decoratableNode && decoratableNode.getDecorators) { // decoratableNode.getDecorators checks for existence of function, which will only be present if it is a DecoratableNode
+            const precisionDecorator = decoratableNode?.getDecorator('Precision');
+            if (precisionDecorator) {
+                // TODO: Verify this is a number type. This could also be a union type that has a number in the case of something like
+                // public myNumber: number | null
+                // or public myNumber?: number
+                // Additionally, this should be moved to the standard decorator pattern
+                const converted = convertPrecisionToC3Type(precisionDecorator);
+                propertyDefinition = new PropertyDefinition(propertyName, converted);
+            }
+            else {
+                const converted = conversionContext.convert(valueDeclaration.getType());
+                propertyDefinition = new PropertyDefinition(propertyName, converted);
+            }
+            if (decoratableNode?.getDecorators()) {
+                for (const decorator of decoratableNode.getDecorators()) {
+                    // We have already handled Precision above
+                    if (decorator.getName() !== 'Precision') {
+                        const c3Decorator = tsDecoratorToC3Decorator(decorator);
+                        if (c3Decorator) {
+                            if (c3Decorator instanceof TenantIdDecorator) {
+                                conversionContext.state().multiTenantSelectionEnabled = true;
+                            }
+                            if (!propertyDefinition.containsDecorator(c3Decorator)) {
+                                propertyDefinition.addDecorator(c3Decorator);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            const converted = conversionContext.convert(valueDeclaration.getType());
+            propertyDefinition = new PropertyDefinition(propertyName, converted);
+        }
+        if (valueDeclaration.getType().isUnion()) {
+            conversionContext.state().unionPropertyNameStack.pop();
+        }
+        return propertyDefinition;
+    }
+}

package/dist/internal/converter/typescript/PrimitiveToC3Type.d.ts

@@ -0,0 +1,10 @@
+import { SpecificTypesConverter } from '../SpecificTypesConverter.js';
+import { Type } from 'ts-morph';
+import { TypescriptConversionState } from './TypescriptConversionState.js';
+import { C3Type } from '@kinotic-ai/idl';
+/**
+ * Converts typescript primitive types to C3Types
+ */
+export declare class PrimitiveToC3Type extends SpecificTypesConverter<Type, C3Type, TypescriptConversionState, string> {
+    constructor();
+}

package/dist/internal/converter/typescript/PrimitiveToC3Type.js

@@ -0,0 +1,33 @@
+import { SpecificTypesConverter } from '../SpecificTypesConverter.js';
+import { BooleanC3Type, StringC3Type, IntC3Type, DateC3Type, VoidC3Type } from '@kinotic-ai/idl';
+/**
+ * Converts typescript primitive types to C3Types
+ */
+export class PrimitiveToC3Type extends SpecificTypesConverter {
+    constructor() {
+        const map = new Map();
+        map.set('string', () => {
+            return new StringC3Type();
+        });
+        map.set('boolean', () => {
+            return new BooleanC3Type();
+        });
+        map.set('number', () => {
+            return new IntC3Type();
+        });
+        map.set('date', () => {
+            return new DateC3Type();
+        });
+        map.set('void', () => {
+            return new VoidC3Type();
+        });
+        super((arg) => {
+            if (arg.isLiteral()) {
+                return arg.getApparentType().getText().toLowerCase();
+            }
+            else {
+                return arg.getText().toLowerCase();
+            }
+        }, map);
+    }
+}

package/dist/internal/converter/typescript/QueryOptionsToC3Type.d.ts

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

package/dist/internal/converter/typescript/QueryOptionsToC3Type.js

@@ -0,0 +1,9 @@
+import { QueryOptionsC3Type } from '@kinotic-ai/os-api';
+export class QueryOptionsToC3Type {
+    convert(value, conversionContext) {
+        return new QueryOptionsC3Type();
+    }
+    supports(value, conversionState) {
+        return value.getAliasSymbol()?.getName() === 'QueryOptions';
+    }
+}

package/dist/internal/converter/typescript/TenantSelectionToC3Type.d.ts

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

package/dist/internal/converter/typescript/TenantSelectionToC3Type.js

@@ -0,0 +1,9 @@
+import { TenantSelectionC3Type } from '@kinotic-ai/os-api';
+export class TenantSelectionToC3Type {
+    convert(value, conversionContext) {
+        return new TenantSelectionC3Type();
+    }
+    supports(value, conversionState) {
+        return value.getAliasSymbol()?.getName() === 'TenantSelection';
+    }
+}

package/dist/internal/converter/typescript/TypescriptConversionState.d.ts

@@ -0,0 +1,24 @@
+import { BaseConversionState } from '../common/BaseConversionState.js';
+/**
+ * The state of the Typescript to C3Type conversion process.
+ */
+export declare class TypescriptConversionState extends BaseConversionState {
+    /**
+     * Contains a stack of object names for objects being processed.
+     */
+    objectNameStack: string[];
+    /**
+     * Contains a stack of property names for any properties processed that are a union type.
+     */
+    unionPropertyNameStack: string[];
+    /**
+     * Boolean to indicate if the source path should be added to the metadata for the {@link C3Type}s created.
+     */
+    shouldAddSourcePathToMetadata: boolean;
+    /**
+     * Boolean to indicate if multi-tenant selection is enabled.
+     * This is done by adding a {@link TenantId} decorator to the entity.
+     */
+    multiTenantSelectionEnabled: boolean;
+    constructor(application: string);
+}