@hadss/turbo-trans-json-plugin 1.0.0-rc.0

package/dist/core/handlers/GenericContainerHandler.js

@@ -0,0 +1,440 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGenericContainerHandlers = createGenericContainerHandlers;
+const ts_morph_1 = require("ts-morph");
+const Types_1 = require("../Types");
+const ITypeHandler_1 = require("./ITypeHandler");
+const BaseTypeHandler_1 = require("./BaseTypeHandler");
+const CustomError_1 = require("../utils/CustomError");
+const Logger_1 = require("../logger/Logger");
+class GenericContainerHandler extends BaseTypeHandler_1.BaseTypeHandler {
+    constructor() {
+        super(...arguments);
+        this.priority = 90;
+    }
+    matches(typeNode) {
+        const syntaxKind = typeNode.getKind();
+        if (syntaxKind === ts_morph_1.SyntaxKind.ArrayType) {
+            return this.kind === Types_1.PropertyKind.ARRAY;
+        }
+        if (syntaxKind === ts_morph_1.SyntaxKind.TypeReference) {
+            const typeRef = typeNode;
+            const refName = typeRef.getTypeName().getText();
+            return this.typeNames.includes(refName);
+        }
+        return false;
+    }
+    parse(typeNode, context) {
+        const syntaxKind = typeNode.getKind();
+        if (syntaxKind === ts_morph_1.SyntaxKind.ArrayType) {
+            return this.parseArrayLiteral(typeNode, context);
+        }
+        if (syntaxKind === ts_morph_1.SyntaxKind.TypeReference) {
+            return this.parseGenericType(typeNode, context);
+        }
+        throw new CustomError_1.CustomError(`Unexpected syntax kind for ${this.name}: ${syntaxKind}`, CustomError_1.ErrorCodes.UNEXPECTED_GENERIC);
+    }
+    parseArrayLiteral(typeNode, context) {
+        const elementTypeNode = typeNode.getElementTypeNode();
+        Logger_1.Logger.debug('GenericHandler.parseArrayLiteral', typeNode.getText(), elementTypeNode.getText(), elementTypeNode.getKind());
+        const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+        const elementType = TypeHandlerRegistry.getInstance().parseType(elementTypeNode, {
+            ...context,
+            depth: context.depth + 1
+        });
+        return {
+            kind: this.kind,
+            depth: context.depth,
+            sourceText: typeNode.getText(),
+            args: [elementType],
+            dependencies: elementType.dependencies
+        };
+    }
+    parseGenericType(typeNode, context) {
+        const typeArgs = typeNode.getTypeArguments();
+        if (typeArgs.length !== this.argsCount) {
+            throw new CustomError_1.CustomError(`${this.name} expects ${this.argsCount} type argument(s), got ${typeArgs.length}`, CustomError_1.ErrorCodes.GENERIC_NOT_MATCH);
+        }
+        const allDependencies = [];
+        const parsedArgs = typeArgs.map((argNode) => {
+            const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+            Logger_1.Logger.debug(`[GenericContainerHandler] parse: ${typeNode.getText()} -> ${typeNode.getKind()}`);
+            const argStructure = TypeHandlerRegistry.getInstance().parseType(argNode, {
+                ...context,
+                depth: context.depth + 1
+            });
+            allDependencies.push(...argStructure.dependencies);
+            return argStructure;
+        });
+        return {
+            kind: this.kind,
+            depth: context.depth,
+            sourceText: typeNode.getText(),
+            args: parsedArgs,
+            dependencies: allDependencies
+        };
+    }
+    getSerializerMetadata(structure, withParam) {
+        const serializerName = this.getSerializerName();
+        const defaultInstantiation = this.generateInstantiation(structure);
+        return {
+            name: serializerName,
+            typeDeclaration: this.generateTypeDeclaration(structure),
+            instantiationTemplate: this.applyWithParam(withParam, defaultInstantiation, structure),
+            encodeMethod: 'encodeSerializableElement',
+            decodeMethod: 'deserialize',
+            decoderType: `${structure.sourceText} | undefined`,
+            needsTypeAssertion: false
+        };
+    }
+    generateInstantiation(structure) {
+        if (!structure.args || structure.args.length !== this.argsCount) {
+            throw new CustomError_1.CustomError(`${this.name}: expected ${this.argsCount} type argument(s), got ${structure.args?.length || 0}`, CustomError_1.ErrorCodes.GENERIC_NOT_MATCH);
+        }
+        if (this.argsCount === 1) {
+            return this.generateSingleArgInstantiation(structure);
+        }
+        else {
+            return this.generateDoubleArgInstantiation(structure);
+        }
+    }
+    generateTypeDeclaration(structure) {
+        if (!structure.args || structure.args.length !== this.argsCount) {
+            throw new CustomError_1.CustomError(`${this.name}: expected ${this.argsCount} type argument(s), got ${structure.args?.length || 0}`, CustomError_1.ErrorCodes.GENERIC_NOT_MATCH);
+        }
+        if (this.argsCount === 1) {
+            return this.generateSingleArgTypeDeclaration(structure);
+        }
+        else {
+            return this.generateDoubleArgTypeDeclaration(structure);
+        }
+    }
+    generateTypeKey() {
+        return this.getTypeKeyString();
+    }
+    generateSingleArgInstantiation(structure) {
+        Logger_1.Logger.info('generateSingleArgInstantiation: sourceText: %s, kind: %s, args: sourceText %s, kind: %s', structure.sourceText, structure.kind, structure.args.map((arg) => arg.sourceText).join(','), structure.args.map((arg) => arg.kind).join(','));
+        const serializerName = this.getSerializerName();
+        const elementType = structure.args[0];
+        const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+        const elementHandler = TypeHandlerRegistry.getInstance().getHandlerForKind(elementType.kind);
+        const elementSerializer = elementHandler.generateInstantiation(elementType);
+        return `new ${serializerName}<${elementType.sourceText}>(${elementSerializer})`;
+    }
+    generateDoubleArgInstantiation(structure) {
+        Logger_1.Logger.info('generateDoubleArgInstantiation:', structure.sourceText, structure.kind, structure.args.join(','));
+        const serializerName = this.getSerializerName();
+        const keyType = structure.args[0];
+        const valueType = structure.args[1];
+        const { TypeHandlerRegistry } = require('./TypeHandlerRegistry');
+        const keyHandler = TypeHandlerRegistry.getInstance().getHandlerForKind(keyType.kind);
+        const valueHandler = TypeHandlerRegistry.getInstance().getHandlerForKind(valueType.kind);
+        const keySerializer = keyHandler.generateInstantiation(keyType);
+        const valueSerializer = valueHandler.generateInstantiation(valueType);
+        return `new ${serializerName}<${keyType.sourceText}, ${valueType.sourceText}>(${keySerializer}, ${valueSerializer})`;
+    }
+    generateSingleArgTypeDeclaration(structure) {
+        const elementType = structure.args[0];
+        const serializerName = this.getSerializerName();
+        return `${serializerName}<${elementType.sourceText}>`;
+    }
+    generateDoubleArgTypeDeclaration(structure) {
+        const keyType = structure.args[0];
+        const valueType = structure.args[1];
+        const serializerName = this.getSerializerName();
+        return `${serializerName}<${keyType.sourceText}, ${valueType.sourceText}>`;
+    }
+    generateSendableTypeDeclaration(structure) {
+        if (!structure.args || structure.args.length !== this.argsCount) {
+            throw new CustomError_1.CustomError(`${this.name}: expected ${this.argsCount} type argument(s), got ${structure.args?.length || 0}`, CustomError_1.ErrorCodes.GENERIC_NOT_MATCH);
+        }
+        const registry = require('./TypeHandlerRegistry').TypeHandlerRegistry.getInstance();
+        if (this.argsCount === 1) {
+            const elementType = structure.args[0];
+            const elementHandler = registry.getHandlerForKind(elementType.kind);
+            const sendableElementType = elementHandler.generateSendableTypeDeclaration(elementType);
+            return `${this.getSendableContainerName()}<${sendableElementType}>`;
+        }
+        else {
+            const keyType = structure.args[0];
+            const valueType = structure.args[1];
+            const keyHandler = registry.getHandlerForKind(keyType.kind);
+            const valueHandler = registry.getHandlerForKind(valueType.kind);
+            const sendableKeyType = keyHandler.generateSendableTypeDeclaration(keyType);
+            const sendableValueType = valueHandler.generateSendableTypeDeclaration(valueType);
+            return `${this.getSendableContainerName()}<${sendableKeyType}, ${sendableValueType}>`;
+        }
+    }
+    generatePropertyConversion(_structure, sourceValue, direction) {
+        if (direction === ITypeHandler_1.ConversionDirection.TO_SENDABLE) {
+            return this.generateToSendableConversion(sourceValue);
+        }
+        else {
+            return this.generateToOriginConversion(sourceValue);
+        }
+    }
+    generateToSendableConversion(sourceValue) {
+        const sendableContainer = this.getSendableContainerName();
+        if (this.argsCount === 1) {
+            return `new ${sendableContainer}(...${sourceValue})`;
+        }
+        else {
+            return `new ${sendableContainer}(${sourceValue}.entries())`;
+        }
+    }
+    generateToOriginConversion(sourceValue) {
+        const originContainer = this.getOriginContainerName();
+        if (this.argsCount === 1) {
+            return `new ${originContainer}(...${sourceValue})`;
+        }
+        else {
+            return `new ${originContainer}(${sourceValue}.entries())`;
+        }
+    }
+}
+class ArrayHandler extends GenericContainerHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'ArrayHandler';
+        this.kind = Types_1.PropertyKind.ARRAY;
+        this.typeNames = ['Array'];
+        this.argsCount = 1;
+    }
+    getTypeKeyString() {
+        return `'array'`;
+    }
+    getSerializerName() {
+        return 'ArraySerializer';
+    }
+    getSendableContainerName() {
+        return 'collections.Array';
+    }
+    getOriginContainerName() {
+        return 'Array';
+    }
+}
+class MapHandler extends GenericContainerHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'MapHandler';
+        this.kind = Types_1.PropertyKind.MAP;
+        this.typeNames = ['Map'];
+        this.argsCount = 2;
+    }
+    getTypeKeyString() {
+        return `'map'`;
+    }
+    getSerializerName() {
+        return 'MapSerializer';
+    }
+    getSendableContainerName() {
+        return 'collections.Map';
+    }
+    getOriginContainerName() {
+        return 'Map';
+    }
+}
+class SetHandler extends GenericContainerHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'SetHandler';
+        this.kind = Types_1.PropertyKind.SET;
+        this.typeNames = ['Set'];
+        this.argsCount = 1;
+    }
+    getTypeKeyString() {
+        return `'set'`;
+    }
+    getSerializerName() {
+        return 'SetSerializer';
+    }
+    getSendableContainerName() {
+        return 'collections.Set';
+    }
+    getOriginContainerName() {
+        return 'Set';
+    }
+}
+class RecordHandler extends GenericContainerHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'RecordHandler';
+        this.kind = Types_1.PropertyKind.RECORD;
+        this.typeNames = ['Record'];
+        this.argsCount = 2;
+    }
+    getTypeKeyString() {
+        return `'map'`;
+    }
+    getSerializerName() {
+        return 'RecordSerializer';
+    }
+    getSendableContainerName() {
+        return 'collections.Map';
+    }
+    getOriginContainerName() {
+        return 'Map';
+    }
+}
+class CollectionsArrayHandler extends GenericContainerHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'CollectionsArrayHandler';
+        this.kind = Types_1.PropertyKind.COLLECTIONS_ARRAY;
+        this.typeNames = ['collections.Array'];
+        this.argsCount = 1;
+    }
+    getTypeKeyString() {
+        return `'array'`;
+    }
+    getSerializerName() {
+        return 'CollectionsArraySerializer';
+    }
+    getSendableContainerName() {
+        return 'collections.Array';
+    }
+    getOriginContainerName() {
+        return 'Array';
+    }
+}
+class CollectionsSetHandler extends GenericContainerHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'CollectionsSetHandler';
+        this.kind = Types_1.PropertyKind.COLLECTIONS_SET;
+        this.typeNames = ['collections.Set'];
+        this.argsCount = 1;
+    }
+    getTypeKeyString() {
+        return `'set'`;
+    }
+    getSerializerName() {
+        return 'CollectionsSetSerializer';
+    }
+    getSendableContainerName() {
+        return 'collections.Set';
+    }
+    getOriginContainerName() {
+        return 'Set';
+    }
+}
+class CollectionsMapHandler extends GenericContainerHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'CollectionsMapHandler';
+        this.kind = Types_1.PropertyKind.COLLECTIONS_MAP;
+        this.typeNames = ['collections.Map'];
+        this.argsCount = 2;
+    }
+    getTypeKeyString() {
+        return `'map'`;
+    }
+    getSerializerName() {
+        return 'CollectionsMapSerializer';
+    }
+    getSendableContainerName() {
+        return 'collections.Map';
+    }
+    getOriginContainerName() {
+        return 'Map';
+    }
+}
+class ArrayListHandler extends GenericContainerHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'ArrayListHandler';
+        this.kind = Types_1.PropertyKind.ARRAY_LIST;
+        this.typeNames = ['ArrayList'];
+        this.argsCount = 1;
+    }
+    getTypeKeyString() {
+        return `'ArrayList'`;
+    }
+    getSerializerName() {
+        return 'ArrayListSerializer';
+    }
+    getSendableContainerName() {
+        throw new CustomError_1.CustomError('toSendable ArrayList type is not supported.', CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
+    }
+    getOriginContainerName() {
+        throw new CustomError_1.CustomError('toOrgin ArrayList type is not supported.', CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
+    }
+}
+class HashMapHandler extends GenericContainerHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'HashMapHandler';
+        this.kind = Types_1.PropertyKind.HASH_MAP;
+        this.typeNames = ['HashMap'];
+        this.argsCount = 2;
+    }
+    getTypeKeyString() {
+        return `'HashMap'`;
+    }
+    getSerializerName() {
+        return 'HashMapSerializer';
+    }
+    getSendableContainerName() {
+        throw new CustomError_1.CustomError('toSendable HashMap type is not supported.', CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
+    }
+    getOriginContainerName() {
+        throw new CustomError_1.CustomError('toOrgin HashMap type is not supported.', CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
+    }
+}
+class HashSetHandler extends GenericContainerHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'HashSetHandler';
+        this.kind = Types_1.PropertyKind.HASH_SET;
+        this.typeNames = ['HashSet'];
+        this.argsCount = 1;
+    }
+    getTypeKeyString() {
+        return `'HashSet'`;
+    }
+    getSerializerName() {
+        return 'HashSetSerializer';
+    }
+    getSendableContainerName() {
+        throw new CustomError_1.CustomError('toSendable HashSet type is not supported.', CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
+    }
+    getOriginContainerName() {
+        throw new CustomError_1.CustomError('toOrgin HashSet type is not supported.', CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
+    }
+}
+class ListHandler extends GenericContainerHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'ListHandler';
+        this.kind = Types_1.PropertyKind.LIST;
+        this.typeNames = ['List'];
+        this.argsCount = 1;
+    }
+    getTypeKeyString() {
+        return `'List'`;
+    }
+    getSerializerName() {
+        return 'ListSerializer';
+    }
+    getSendableContainerName() {
+        throw new CustomError_1.CustomError('toSendable List type is not supported.', CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
+    }
+    getOriginContainerName() {
+        throw new CustomError_1.CustomError('toOrgin List type is not supported.', CustomError_1.ErrorCodes.TYPE_NOT_SUPPORT);
+    }
+}
+function createGenericContainerHandlers() {
+    return [
+        new ArrayHandler(),
+        new SetHandler(),
+        new MapHandler(),
+        new RecordHandler(),
+        new CollectionsArrayHandler(),
+        new CollectionsSetHandler(),
+        new CollectionsMapHandler(),
+        new ArrayListHandler(),
+        new HashMapHandler(),
+        new HashSetHandler(),
+        new ListHandler()
+    ];
+}

package/dist/core/handlers/GenericHandler.d.ts

@@ -0,0 +1,18 @@
+import { TypeNode } from 'ts-morph';
+import { PropertyKind, TypeStructure, SerializerMetadata } from '../Types';
+import { ITypeHandler, TypeContext, ConversionDirection } from './ITypeHandler';
+import { BaseTypeHandler } from './BaseTypeHandler';
+export declare class GenericHandler extends BaseTypeHandler implements ITypeHandler {
+    readonly name = "GenericHandler";
+    readonly kind = PropertyKind.GENERIC;
+    readonly priority = 95;
+    matches(typeNode: TypeNode, context: TypeContext): boolean;
+    parse(typeNode: TypeNode): TypeStructure;
+    getSerializerMetadata(structure: TypeStructure, withParam?: string): SerializerMetadata;
+    generateInstantiation(structure: TypeStructure): string;
+    generateTypeDeclaration(structure: TypeStructure): string;
+    generateTypeKey(structure: TypeStructure): string;
+    generateSendableTypeDeclaration(structure: TypeStructure): string;
+    generatePropertyConversion(structure: TypeStructure, sourceValue: string, direction: ConversionDirection): string;
+}
+export declare function createGenericHandler(): ITypeHandler;

package/dist/core/handlers/GenericHandler.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericHandler = void 0;
+exports.createGenericHandler = createGenericHandler;
+const ts_morph_1 = require("ts-morph");
+const Types_1 = require("../Types");
+const ITypeHandler_1 = require("./ITypeHandler");
+const BaseTypeHandler_1 = require("./BaseTypeHandler");
+class GenericHandler extends BaseTypeHandler_1.BaseTypeHandler {
+    constructor() {
+        super(...arguments);
+        this.name = 'GenericHandler';
+        this.kind = Types_1.PropertyKind.GENERIC;
+        this.priority = 95;
+    }
+    matches(typeNode, context) {
+        if (typeNode.getKind() !== ts_morph_1.SyntaxKind.TypeReference) {
+            return false;
+        }
+        const typeRef = typeNode;
+        const typeName = typeRef.getTypeName().getText();
+        if (typeRef.getTypeArguments().length > 0) {
+            return false;
+        }
+        return context.genericParams.includes(typeName);
+    }
+    parse(typeNode) {
+        const typeRef = typeNode;
+        const typeName = typeRef.getTypeName().getText();
+        return {
+            kind: this.kind,
+            depth: 0,
+            sourceText: typeName,
+            args: [],
+            dependencies: []
+        };
+    }
+    getSerializerMetadata(structure, withParam) {
+        const defaultInstantiation = this.generateInstantiation(structure);
+        return {
+            name: 'Serializer',
+            typeDeclaration: this.generateTypeDeclaration(structure),
+            instantiationTemplate: this.applyWithParam(withParam, defaultInstantiation, structure),
+            encodeMethod: 'encodeSerializableElement',
+            decodeMethod: 'deserialize',
+            decoderType: `${structure.sourceText} | undefined`,
+            needsTypeAssertion: false
+        };
+    }
+    generateInstantiation(structure) {
+        const typeName = structure.sourceText;
+        const lowerName = typeName.toLowerCase();
+        return `${lowerName}Serializer`;
+    }
+    generateTypeDeclaration(structure) {
+        const typeName = structure.sourceText;
+        return `Serializer<${typeName}>`;
+    }
+    generateTypeKey(structure) {
+        const typeName = structure.sourceText;
+        return `'${typeName}'`;
+    }
+    generateSendableTypeDeclaration(structure) {
+        return structure.sourceText;
+    }
+    generatePropertyConversion(structure, sourceValue, direction) {
+        if (direction === ITypeHandler_1.ConversionDirection.TO_SENDABLE) {
+            return `((): ${structure.sourceText}${structure.isOptional ? ' | undefined' : ''} => {
+                const sendable: ESObject = ${sourceValue};
+                if (sendable.toSendable) {
+                  return sendable.toSendable();
+                } else {
+                  return ${sourceValue}${structure.isOptional ? '' : '!'};
+                }
+              })()`;
+        }
+        else {
+            return `((): ${structure.sourceText}${structure.isOptional ? ' | undefined' : ''} => {
+                const origin: ESObject = ${sourceValue};
+                if (origin.toOrigin) {
+                  return origin.toOrigin();
+                } else {
+                  return ${sourceValue}${structure.isOptional ? '' : '!'};
+                }
+              })()`;
+        }
+    }
+}
+exports.GenericHandler = GenericHandler;
+function createGenericHandler() {
+    return new GenericHandler();
+}

package/dist/core/handlers/HandlerBootstrap.d.ts

@@ -0,0 +1,2 @@
+import { TypeHandlerRegistry } from './TypeHandlerRegistry';
+export declare function initializeTypeHandlers(): TypeHandlerRegistry;

package/dist/core/handlers/HandlerBootstrap.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeTypeHandlers = initializeTypeHandlers;
+const TypeHandlerRegistry_1 = require("./TypeHandlerRegistry");
+const PrimitiveHandler_1 = require("./PrimitiveHandler");
+const GenericContainerHandler_1 = require("./GenericContainerHandler");
+const UnionTypeHandler_1 = require("./UnionTypeHandler");
+const EnumHandler_1 = require("./EnumHandler");
+const GenericHandler_1 = require("./GenericHandler");
+const CustomClassHandler_1 = require("./CustomClassHandler");
+const TupleHandler_1 = require("./TupleHandler");
+const DateHandler_1 = require("./DateHandler");
+const DecimalHandler_1 = require("./DecimalHandler");
+function initializeTypeHandlers() {
+    const registry = TypeHandlerRegistry_1.TypeHandlerRegistry.getInstance();
+    registry.registerAll((0, PrimitiveHandler_1.createPrimitiveHandlers)());
+    registry.registerAll((0, GenericContainerHandler_1.createGenericContainerHandlers)());
+    registry.registerAll((0, UnionTypeHandler_1.createUnionTypeHandlers)());
+    registry.register((0, EnumHandler_1.createEnumHandler)());
+    registry.register((0, GenericHandler_1.createGenericHandler)());
+    registry.register((0, CustomClassHandler_1.createCustomClassHandler)());
+    registry.register((0, TupleHandler_1.createTupleTypeHandlers)());
+    registry.register((0, DateHandler_1.createDateHandler)());
+    registry.registerAll([
+        (0, DecimalHandler_1.createDecimalHandler)()
+    ]);
+    return registry;
+}

package/dist/core/handlers/ITypeHandler.d.ts

@@ -0,0 +1,23 @@
+import { TypeNode } from 'ts-morph';
+import { PropertyKind, SerializerMetadata, TypeStructure } from '..';
+export interface ITypeHandler {
+    readonly name: string;
+    readonly kind: PropertyKind;
+    readonly priority: number;
+    matches(typeNode: TypeNode, context: TypeContext): boolean;
+    parse(typeNode: TypeNode, context: TypeContext): TypeStructure;
+    getSerializerMetadata(structure: TypeStructure, withParam?: string): SerializerMetadata;
+    generateInstantiation(structure: TypeStructure): string;
+    generateTypeDeclaration(structure: TypeStructure): string;
+    generateTypeKey(structure: TypeStructure): string;
+    generateSendableTypeDeclaration(structure: TypeStructure): string;
+    generatePropertyConversion(structure: TypeStructure, sourceValue: string, direction: ConversionDirection): string;
+}
+export interface TypeContext {
+    genericParams: string[];
+    depth: number;
+}
+export declare enum ConversionDirection {
+    TO_SENDABLE = "TO_SENDABLE",
+    TO_ORIGIN = "TO_ORIGIN"
+}

package/dist/core/handlers/ITypeHandler.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversionDirection = void 0;
+var ConversionDirection;
+(function (ConversionDirection) {
+    ConversionDirection["TO_SENDABLE"] = "TO_SENDABLE";
+    ConversionDirection["TO_ORIGIN"] = "TO_ORIGIN";
+})(ConversionDirection || (exports.ConversionDirection = ConversionDirection = {}));

package/dist/core/handlers/PrimitiveHandler.d.ts

@@ -0,0 +1,2 @@
+import { ITypeHandler } from './ITypeHandler';
+export declare function createPrimitiveHandlers(): ITypeHandler[];