nitrogen 0.29.8 → 0.30.1

package/lib/syntax/kotlin/KotlinBoxedPrimitive.d.ts

@@ -0,0 +1,7 @@
+import type { Type } from '../types/Type.js';
+/**
+ * Returns a boxed version of the given primitive type.
+ * In JNI/Kotlin, primitive types (like `double` or `boolean`)
+ * cannot be nullable, so we need to box them - e.g. as `JDouble` or `JBoolean`.
+ */
+export declare function getKotlinBoxedPrimitiveType(type: Type): string;

package/lib/syntax/kotlin/KotlinCxxBridgedType.d.ts

@@ -0,0 +1,19 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import type { BridgedType } from '../BridgedType.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { Type } from '../types/Type.js';
+export declare class KotlinCxxBridgedType implements BridgedType<'kotlin', 'c++'> {
+    readonly type: Type;
+    constructor(type: Type);
+    get hasType(): boolean;
+    get canBePassedByReference(): boolean;
+    get needsSpecialHandling(): boolean;
+    getRequiredImports(language: Language): SourceImport[];
+    getExtraFiles(): SourceFile[];
+    asJniReferenceType(referenceType?: 'alias' | 'local' | 'global'): string;
+    getTypeCode(language: 'kotlin' | 'c++', isBoxed?: boolean): string;
+    parse(parameterName: string, from: 'c++' | 'kotlin', to: 'kotlin' | 'c++', inLanguage: 'kotlin' | 'c++'): string;
+    parseFromCppToKotlin(parameterName: string, language: 'kotlin' | 'c++', isBoxed?: boolean): string;
+    parseFromKotlinToCpp(parameterName: string, language: 'kotlin' | 'c++', isBoxed?: boolean): string;
+    private getFullJHybridObjectName;
+}

package/lib/syntax/kotlin/KotlinCxxBridgedType.js

@@ -32,10 +32,6 @@ export class KotlinCxxBridgedType {
             case 'function':
                 // Function needs to be converted from JFunc_... to Lambda
                 return true;
-            case 'struct':
-                // Structs don't need special handling - they have direct mappings
-                // Returning false prevents secondary constructor generation that causes duplicates
-                return false;
             case 'optional':
                 // Optionals need special handling if the wrapped type needs special handling
                 const optional = getTypeAs(this.type, OptionalType);
@@ -44,16 +40,6 @@ export class KotlinCxxBridgedType {
             default:
                 break;
         }
-        // check if any types this type references (e.g. underlying optional, array element, ...)
-        // needs special handling. if yes, we need it as well
-        const referencedTypes = getReferencedTypes(this.type)
-            .filter((t) => t !== this.type)
-            .map((t) => new KotlinCxxBridgedType(t));
-        for (const type of referencedTypes) {
-            if (type.needsSpecialHandling) {
-                return true;
-            }
-        }
         // no special handling needed
         return false;
     }

package/lib/syntax/kotlin/KotlinEnum.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../SourceFile.js';
+import { EnumType } from '../types/EnumType.js';
+export declare function createKotlinEnum(enumType: EnumType): SourceFile[];

package/lib/syntax/kotlin/KotlinFunction.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../SourceFile.js';
+import type { FunctionType } from '../types/FunctionType.js';
+export declare function createKotlinFunction(functionType: FunctionType): SourceFile[];

package/lib/syntax/kotlin/KotlinHybridObject.d.ts

@@ -0,0 +1,3 @@
+import type { HybridObjectSpec } from '../HybridObjectSpec.js';
+import type { SourceFile } from '../SourceFile.js';
+export declare function createKotlinHybridObject(spec: HybridObjectSpec): SourceFile[];

package/lib/syntax/kotlin/KotlinHybridObject.js

@@ -81,7 +81,7 @@ abstract class ${name.HybridTSpec}: ${kotlinBase}() {
   private external fun initHybrid(): HybridData
 
   companion object {
-    private const val TAG = "${name.HybridTSpec}"
+    protected const val TAG = "${name.HybridTSpec}"
   }
 }
   `.trim();

package/lib/syntax/kotlin/KotlinHybridObjectRegistration.d.ts

@@ -0,0 +1,17 @@
+import type { SourceImport } from '../SourceFile.js';
+interface Props {
+    /**
+     * The name of the Hybrid Object under which it should be registered and exposed to JS to.
+     */
+    hybridObjectName: string;
+    /**
+     * The name of the Kotlin/Java class that will be default-constructed
+     */
+    jniClassName: string;
+}
+interface JNIHybridObjectRegistration {
+    cppCode: string;
+    requiredImports: SourceImport[];
+}
+export declare function createJNIHybridObjectRegistration({ hybridObjectName, jniClassName, }: Props): JNIHybridObjectRegistration;
+export {};

package/lib/syntax/kotlin/KotlinStruct.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../SourceFile.js';
+import type { StructType } from '../types/StructType.js';
+export declare function createKotlinStruct(structType: StructType): SourceFile[];

package/lib/syntax/kotlin/KotlinStruct.js

@@ -6,40 +6,25 @@ import { createFileMetadataString, isNotDuplicate } from '../helpers.js';
 import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js';
 export function createKotlinStruct(structType) {
     const packageName = NitroConfig.current.getAndroidPackage('java/kotlin');
-    const values = structType.properties.map((p) => {
-        const bridged = new KotlinCxxBridgedType(p);
-        return `
+    const parameters = structType.properties
+        .map((p) => `
 @DoNotStrip
 @Keep
-val ${p.escapedName}: ${bridged.getTypeCode('kotlin', false)}
-`.trim();
-    });
-    let secondaryConstructor;
-    const needsSpecialHandling = structType.properties.some((p) => new KotlinCxxBridgedType(p).needsSpecialHandling);
-    if (needsSpecialHandling) {
-        // If we need special handling for any of our properties, we need to add a convenience initializer.
-        const params = structType.properties.map((p) => `${p.escapedName}: ${p.getCode('kotlin')}`);
-        const paramsForward = structType.properties.map((p) => {
-            const bridged = new KotlinCxxBridgedType(p);
-            if (bridged.needsSpecialHandling) {
-                // We need special parsing for this type
-                return bridged.parseFromKotlinToCpp(p.escapedName, 'kotlin', false);
-            }
-            else {
-                return p.escapedName;
-            }
-        });
-        secondaryConstructor = `
-/**
- * Initialize a new instance of \`${structType.structName}\` from Kotlin.
- */
-constructor(${indent(params.join(', '), 12)})
-     : this(${indent(paramsForward.join(', '), 12)})
-    `.trim();
-    }
-    else {
-        secondaryConstructor = `/* main constructor */`;
-    }
+val ${p.escapedName}: ${p.getCode('kotlin')}
+`.trim())
+        .join(',\n');
+    const cxxCreateFunctionParameters = structType.properties
+        .map((p) => {
+        const bridged = new KotlinCxxBridgedType(p);
+        return `${p.escapedName}: ${bridged.getTypeCode('kotlin', false)}`;
+    })
+        .join(', ');
+    const cxxCreateFunctionForward = structType.properties
+        .map((p) => {
+        const bridged = new KotlinCxxBridgedType(p);
+        return bridged.parseFromCppToKotlin(p.escapedName, 'kotlin', false);
+    })
+        .join(', ');
     const extraImports = structType.properties
         .flatMap((t) => t.getRequiredImports('kotlin'))
         .map((i) => `import ${i.name}`);
@@ -58,13 +43,21 @@ ${extraImports.join('\n')}
  */
 @DoNotStrip
 @Keep
-data class ${structType.structName}
-  @DoNotStrip
-  @Keep
-  constructor(
-    ${indent(values.join(',\n'), '    ')}
-  ) {
-  ${indent(secondaryConstructor, '  ')}
+data class ${structType.structName}(
+  ${indent(parameters, '  ')}
+) {
+  private companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(${cxxCreateFunctionParameters}): ${structType.structName} {
+      return ${structType.structName}(${cxxCreateFunctionForward})
+    }
+  }
 }
   `.trim();
     const cxxNamespace = NitroConfig.current.getCxxNamespace('c++');
@@ -159,14 +152,26 @@ function createJNIStructInitializer(structType) {
     return lines.join('\n');
 }
 function createCppStructInitializer(cppValueName, structType) {
-    const lines = [];
-    lines.push(`return newInstance(`);
-    const names = structType.properties.map((p) => {
+    const jniTypes = structType.properties
+        .map((p) => {
+        const bridge = new KotlinCxxBridgedType(p);
+        return bridge.asJniReferenceType('alias');
+    })
+        .join(', ');
+    const params = structType.properties
+        .map((p) => {
         const name = `${cppValueName}.${p.escapedName}`;
         const bridge = new KotlinCxxBridgedType(p);
         return bridge.parse(name, 'c++', 'kotlin', 'c++');
-    });
-    lines.push(`  ${indent(names.join(',\n'), '  ')}`);
-    lines.push(');');
-    return lines.join('\n');
+    })
+        .join(',\n');
+    return `
+using JSignature = J${structType.structName}(${jniTypes});
+static const auto clazz = javaClassStatic();
+static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+return create(
+  clazz,
+  ${indent(params, '  ')}
+);
+  `.trim();
 }

package/lib/syntax/kotlin/KotlinVariant.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../SourceFile.js';
+import { type VariantType } from '../types/VariantType.js';
+export declare function createKotlinVariant(variant: VariantType): SourceFile[];

package/lib/syntax/kotlin/KotlinVariant.js

@@ -2,17 +2,19 @@ import { NitroConfig } from '../../config/NitroConfig.js';
 import { capitalizeName, indent } from '../../utils.js';
 import { includeHeader } from '../c++/includeNitroHeader.js';
 import { createFileMetadataString, isNotDuplicate, toReferenceType, } from '../helpers.js';
+import { OptionalType } from '../types/OptionalType.js';
 import {} from '../types/VariantType.js';
 import { KotlinCxxBridgedType } from './KotlinCxxBridgedType.js';
 export function createKotlinVariant(variant) {
-    const jsName = variant.variants.map((v) => v.getCode('kotlin')).join('|');
+    const jsName = variant.variants.map((v) => v.getCode('kotlin')).join(' | ');
     const kotlinName = variant.getAliasName('kotlin');
     const namespace = `J${kotlinName}_impl`;
     const innerClasses = variant.cases.map(([label, v]) => {
         const innerName = capitalizeName(label);
+        const bridge = new KotlinCxxBridgedType(v);
         return `
 @DoNotStrip
-data class ${innerName}(@DoNotStrip val value: ${v.getCode('kotlin')}): ${kotlinName}()
+data class ${innerName}(@DoNotStrip val value: ${bridge.getTypeCode('kotlin')}): ${kotlinName}()
       `.trim();
     });
     const packageName = NitroConfig.current.getAndroidPackage('java/kotlin');
@@ -25,15 +27,37 @@ data class ${innerName}(@DoNotStrip val value: ${v.getCode('kotlin')}): ${kotlin
         return `
 val is${innerName}: Boolean
   get() = this is ${innerName}
+    `.trim();
+    });
+    const asFunctions = variant.cases.map(([label, v]) => {
+        const innerName = capitalizeName(label);
+        const bridge = new KotlinCxxBridgedType(v);
+        const optional = new OptionalType(v);
+        return `
+fun as${innerName}OrNull(): ${optional.getCode('kotlin')} {
+  val value = (this as? ${innerName})?.value ?: return null
+  return ${bridge.parseFromCppToKotlin('value', 'kotlin')}
+}
+    `.trim();
+    });
+    const matchParameters = variant.cases.map(([label, v]) => {
+        return `${label}: (${v.getCode('kotlin')}) -> R`;
+    });
+    const matchCases = variant.cases.map(([label, v]) => {
+        const innerName = capitalizeName(label);
+        const bridge = new KotlinCxxBridgedType(v);
+        return `
+is ${innerName} -> ${label}(${bridge.parseFromCppToKotlin('value', 'kotlin')})
     `.trim();
     });
     const createFunctions = variant.cases.map(([label, v]) => {
+        const bridge = new KotlinCxxBridgedType(v);
         const innerName = capitalizeName(label);
         return `
 @JvmStatic
 @DoNotStrip
-fun create(value: ${v.getCode('kotlin')}): ${kotlinName} = ${innerName}(value)
-    `.trim();
+fun create(value: ${bridge.getTypeCode('kotlin')}): ${kotlinName} = ${innerName}(${bridge.parseFromCppToKotlin('value', 'kotlin')})
+`.trim();
     });
     const extraImports = variant.variants
         .flatMap((t) => t.getRequiredImports('kotlin'))
@@ -54,12 +78,21 @@ ${extraImports.join('\n')}
 sealed class ${kotlinName} {
   ${indent(innerClasses.join('\n'), '  ')}
 
+  @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR)
   inline fun <reified T> getAs(): T? = when (this) {
     ${indent(getterCases.join('\n'), '    ')}
   }
 
   ${indent(isFunctions.join('\n'), '  ')}
 
+  ${indent(asFunctions.join('\n'), '  ')}
+
+  inline fun <R> match(${matchParameters.join(', ')}): R {
+    return when (this) {
+      ${indent(matchCases.join('\n'), '      ')}
+    }
+  }
+
   companion object {
     ${indent(createFunctions.join('\n'), '    ')}
   }

package/lib/syntax/swift/SwiftCxxBridgedType.d.ts

@@ -0,0 +1,21 @@
+import type { BridgedType } from '../BridgedType.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { Type } from '../types/Type.js';
+import { type SwiftCxxHelper } from './SwiftCxxTypeHelper.js';
+import type { Language } from '../../getPlatformSpecs.js';
+export declare class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> {
+    readonly type: Type;
+    private readonly isBridgingToDirectCppTarget;
+    constructor(type: Type, isBridgingToDirectCppTarget?: boolean);
+    get hasType(): boolean;
+    get canBePassedByReference(): boolean;
+    get needsSpecialHandling(): boolean;
+    getRequiredBridge(): SwiftCxxHelper | undefined;
+    private getBridgeOrThrow;
+    getRequiredImports(language: Language): SourceImport[];
+    getExtraFiles(): SourceFile[];
+    getTypeCode(language: 'swift' | 'c++'): string;
+    parse(parameterName: string, from: 'c++' | 'swift', to: 'swift' | 'c++', inLanguage: 'swift' | 'c++'): string;
+    parseFromCppToSwift(cppParameterName: string, language: 'swift' | 'c++'): string;
+    parseFromSwiftToCpp(swiftParameterName: string, language: 'swift' | 'c++'): string;
+}

package/lib/syntax/swift/SwiftCxxBridgedType.js

@@ -14,7 +14,7 @@ import { StructType } from '../types/StructType.js';
 import { TupleType } from '../types/TupleType.js';
 import { VariantType } from '../types/VariantType.js';
 import { getReferencedTypes } from '../getReferencedTypes.js';
-import { createSwiftCxxHelpers, isPrimitivelyCopyable, } from './SwiftCxxTypeHelper.js';
+import { createSwiftCxxHelpers, } from './SwiftCxxTypeHelper.js';
 import { createSwiftEnumBridge } from './SwiftEnum.js';
 import { createSwiftStructBridge } from './SwiftStruct.js';
 import { createSwiftVariant } from './SwiftVariant.js';
@@ -22,6 +22,7 @@ import { VoidType } from '../types/VoidType.js';
 import { NamedWrappingType } from '../types/NamedWrappingType.js';
 import { ErrorType } from '../types/ErrorType.js';
 import { createSwiftFunctionBridge } from './SwiftFunction.js';
+import { isPrimitivelyCopyable } from './isPrimitivelyCopyable.js';
 // TODO: Remove enum bridge once Swift fixes bidirectional enums crashing the `-Swift.h` header.
 export class SwiftCxxBridgedType {
     type;
@@ -408,7 +409,9 @@ export class SwiftCxxBridgedType {
                                 return `${cppParameterName}.has_value() ? ${cppParameterName}.pointee : nil`;
                             }
                         }
-                        if (!wrapping.needsSpecialHandling) {
+                        // TODO: Remove this check for booleans once https://github.com/swiftlang/swift/issues/84848 is fixed.
+                        const swiftBug84848Workaround = optional.wrappingType.kind === 'boolean';
+                        if (!wrapping.needsSpecialHandling && !swiftBug84848Workaround) {
                             return `${cppParameterName}.value`;
                         }
                         return `

package/lib/syntax/swift/SwiftCxxTypeHelper.d.ts

@@ -15,4 +15,3 @@ export interface SwiftCxxHelper {
     dependencies: SwiftCxxHelper[];
 }
 export declare function createSwiftCxxHelpers(type: Type): SwiftCxxHelper | undefined;
-export declare function isPrimitivelyCopyable(type: Type): boolean;

package/lib/syntax/swift/SwiftCxxTypeHelper.js

@@ -17,6 +17,7 @@ import { VoidType } from '../types/VoidType.js';
 import { NamedWrappingType } from '../types/NamedWrappingType.js';
 import { ErrorType } from '../types/ErrorType.js';
 import { ResultWrappingType } from '../types/ResultWrappingType.js';
+import { isPrimitivelyCopyable } from './isPrimitivelyCopyable.js';
 export function createSwiftCxxHelpers(type) {
     switch (type.kind) {
         case 'hybrid-object':
@@ -116,7 +117,7 @@ return ${cxxNamespace}::get_${internalName}(cppType);
  */
 using ${name} = ${actualType};
 ${actualType} create_${name}(void* NON_NULL swiftUnsafePointer) noexcept;
-void* NON_NULL get_${name}(${name} cppType) noexcept;
+void* NON_NULL get_${name}(${name} cppType);
     `.trim(),
             requiredIncludes: type.getRequiredImports('c++'),
         },
@@ -125,7 +126,7 @@ void* NON_NULL get_${name}(${name} cppType) noexcept;
 ${actualType} create_${name}(void* NON_NULL swiftUnsafePointer) noexcept {
   ${indent(createImplementation, '  ')}
 }
-void* NON_NULL get_${name}(${name} cppType) noexcept {
+void* NON_NULL get_${name}(${name} cppType) {
   ${indent(getImplementation, '  ')}
 }
     `.trim(),
@@ -219,10 +220,6 @@ inline ${wrappedBridge.getTypeCode('c++')} get_${name}(const ${actualType}& opti
         dependencies: [],
     };
 }
-export function isPrimitivelyCopyable(type) {
-    const bridgedType = new SwiftCxxBridgedType(type, true);
-    return !bridgedType.needsSpecialHandling;
-}
 /**
  * Creates a C++ `create_vector_T<T>(size)` function that can be called from Swift.
  */

package/lib/syntax/swift/SwiftEnum.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../SourceFile.js';
+import type { EnumType } from '../types/EnumType.js';
+export declare function createSwiftEnumBridge(enumType: EnumType): SourceFile;

package/lib/syntax/swift/SwiftFunction.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../SourceFile.js';
+import type { FunctionType } from '../types/FunctionType.js';
+export declare function createSwiftFunctionBridge(functionType: FunctionType): SourceFile;

package/lib/syntax/swift/SwiftHybridObject.d.ts

@@ -0,0 +1,3 @@
+import type { HybridObjectSpec } from '../HybridObjectSpec.js';
+import type { SourceFile } from '../SourceFile.js';
+export declare function createSwiftHybridObject(spec: HybridObjectSpec): SourceFile[];

package/lib/syntax/swift/SwiftHybridObjectBridge.d.ts

@@ -0,0 +1,11 @@
+import type { HybridObjectSpec } from '../HybridObjectSpec.js';
+import type { SourceFile } from '../SourceFile.js';
+/**
+ * Creates a Swift class that bridges Swift over to C++.
+ * We need this because not all Swift types are accessible in C++, and vice versa.
+ *
+ * For example, Enums need to be converted to Int32 (because of a Swift compiler bug),
+ * Promise<..> has to be converted to a Promise<..>, exceptions have to be handled
+ * via custom Result types, etc..
+ */
+export declare function createSwiftHybridObjectCxxBridge(spec: HybridObjectSpec): SourceFile[];

package/lib/syntax/swift/SwiftHybridObjectRegistration.d.ts

@@ -0,0 +1,19 @@
+import type { SourceImport } from '../SourceFile.js';
+interface Props {
+    /**
+     * The name of the Hybrid Object under which it should be registered and exposed to JS to.
+     */
+    hybridObjectName: string;
+    /**
+     * The name of the Swift class that will be default-constructed
+     */
+    swiftClassName: string;
+}
+interface SwiftHybridObjectRegistration {
+    cppCode: string;
+    swiftFunction: string;
+    requiredImports: SourceImport[];
+}
+export declare function getHybridObjectConstructorCall(hybridObjectName: string): string;
+export declare function createSwiftHybridObjectRegistration({ hybridObjectName, swiftClassName, }: Props): SwiftHybridObjectRegistration;
+export {};

package/lib/syntax/swift/SwiftStruct.d.ts

@@ -0,0 +1,3 @@
+import type { FileWithReferencedTypes } from '../SourceFile.js';
+import { StructType } from '../types/StructType.js';
+export declare function createSwiftStructBridge(struct: StructType): FileWithReferencedTypes;

package/lib/syntax/swift/SwiftVariant.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../SourceFile.js';
+import type { VariantType } from '../types/VariantType.js';
+export declare function createSwiftVariant(variant: VariantType): SourceFile;

package/lib/syntax/swift/isPrimitivelyCopyable.d.ts

@@ -0,0 +1,7 @@
+import type { Type } from '../types/Type.js';
+/**
+ * Returns `true` if the given {@linkcode type} is a datatype that
+ * can be copied without running a copy constructor or special logic
+ * to copy the data over. In other words; it's _primitively copyable_.
+ */
+export declare function isPrimitivelyCopyable(type: Type): boolean;

package/lib/syntax/swift/isPrimitivelyCopyable.js

@@ -0,0 +1,18 @@
+/**
+ * Returns `true` if the given {@linkcode type} is a datatype that
+ * can be copied without running a copy constructor or special logic
+ * to copy the data over. In other words; it's _primitively copyable_.
+ */
+export function isPrimitivelyCopyable(type) {
+    switch (type.kind) {
+        case 'number':
+        case 'boolean':
+        case 'bigint':
+        case 'enum':
+        case 'null':
+        case 'void':
+            return true;
+        default:
+            return false;
+    }
+}

package/lib/syntax/types/ArrayBufferType.d.ts

@@ -0,0 +1,10 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { Type, TypeKind } from './Type.js';
+export declare class ArrayBufferType implements Type {
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

package/lib/syntax/types/BigIntType.d.ts

@@ -0,0 +1,10 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { Type, TypeKind } from './Type.js';
+export declare class BigIntType implements Type {
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(): SourceImport[];
+}

package/lib/syntax/types/BooleanType.d.ts

@@ -0,0 +1,10 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { Type, TypeKind } from './Type.js';
+export declare class BooleanType implements Type {
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(): SourceImport[];
+}

package/lib/syntax/types/DateType.d.ts

@@ -0,0 +1,10 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { Type, TypeKind } from './Type.js';
+export declare class DateType implements Type {
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

package/lib/syntax/types/EnumType.d.ts

@@ -0,0 +1,23 @@
+import { EnumDeclaration } from 'ts-morph';
+import { Type as TSMorphType, type ts } from 'ts-morph';
+import type { Language } from '../../getPlatformSpecs.js';
+import { type SourceFile, type SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, Type, TypeKind } from './Type.js';
+export interface EnumMember {
+    name: string;
+    value: number;
+    stringValue: string;
+}
+export declare class EnumType implements Type {
+    readonly enumName: string;
+    readonly enumMembers: EnumMember[];
+    readonly jsType: 'enum' | 'union';
+    readonly declarationFile: SourceFile;
+    constructor(enumName: string, enumDeclaration: EnumDeclaration);
+    constructor(enumName: string, union: TSMorphType<ts.UnionType>);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language, { fullyQualified }?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

package/lib/syntax/types/ErrorType.d.ts

@@ -0,0 +1,11 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import { type SourceFile, type SourceImport } from '../SourceFile.js';
+import type { Type, TypeKind } from './Type.js';
+export declare class ErrorType implements Type {
+    constructor();
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

package/lib/syntax/types/FunctionType.d.ts

@@ -0,0 +1,29 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import { type SourceFile, type SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, NamedType, Type, TypeKind } from './Type.js';
+export interface GetFunctionCodeOptions extends GetCodeOptions {
+    includeNameInfo?: boolean;
+}
+export declare class FunctionType implements Type {
+    readonly returnType: Type;
+    readonly parameters: NamedType[];
+    constructor(returnType: Type, parameters: NamedType[], isSync?: boolean);
+    get specializationName(): string;
+    get jsName(): string;
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    /**
+     * For a function, get the forward recreation of it:
+     * If variable is called `func`, this would return:
+     * ```cpp
+     * [func = std::move(func)](Params... params) -> ReturnType {
+     *   return func(params...);
+     * }
+     * ```
+     */
+    getForwardRecreationCode(variableName: string, language: Language): string;
+    getCppFunctionPointerType(name: string, includeNameInfo?: boolean): string;
+    getCode(language: Language, options?: GetFunctionCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

package/lib/syntax/types/HybridObjectBaseType.d.ts

@@ -0,0 +1,11 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { Type, TypeKind } from './Type.js';
+export declare class HybridObjectBaseType implements Type {
+    constructor();
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}