nitrogen 0.29.8 → 0.30.0

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/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/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

@@ -15,7 +15,11 @@ val ${p.escapedName}: ${bridged.getTypeCode('kotlin', false)}
 `.trim();
     });
     let secondaryConstructor;
-    const needsSpecialHandling = structType.properties.some((p) => new KotlinCxxBridgedType(p).needsSpecialHandling);
+    const needsSpecialHandling = structType.properties.some((p) => {
+        const bridged = new KotlinCxxBridgedType(p);
+        const parseCode = bridged.parseFromKotlinToCpp(p.escapedName, 'kotlin', false);
+        return parseCode !== p.escapedName;
+    });
     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')}`);

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/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;

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[];
+}

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

@@ -0,0 +1,23 @@
+import { type NitroConfig } from '../../config/NitroConfig.js';
+import type { Language } from '../../getPlatformSpecs.js';
+import type { HybridObjectSpec } from '../HybridObjectSpec.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, Type, TypeKind } from './Type.js';
+interface GetHybridObjectCodeOptions extends GetCodeOptions {
+    mode?: 'strong' | 'weak';
+}
+export declare class HybridObjectType implements Type {
+    readonly hybridObjectName: string;
+    readonly implementationLanguage: Language;
+    readonly baseTypes: HybridObjectType[];
+    readonly sourceConfig: NitroConfig;
+    constructor(hybridObjectName: string, implementationLanguage: Language, baseTypes: HybridObjectType[], sourceConfig: NitroConfig);
+    constructor(spec: HybridObjectSpec);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language, options?: GetHybridObjectCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    private getExternalCxxImportName;
+    getRequiredImports(language: Language): SourceImport[];
+}
+export {};

package/lib/syntax/types/MapType.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 MapType implements Type {
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

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

@@ -0,0 +1,14 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, NamedType, Type, TypeKind } from './Type.js';
+export declare class NamedWrappingType<T extends Type> implements NamedType {
+    readonly type: T;
+    readonly name: string;
+    constructor(name: string, type: T);
+    get escapedName(): string;
+    get kind(): TypeKind;
+    get canBePassedByReference(): boolean;
+    getCode(language: Language, options?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

package/lib/syntax/types/NullType.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 NullType implements Type {
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(): SourceImport[];
+}

package/lib/syntax/types/NumberType.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 NumberType implements Type {
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(): SourceImport[];
+}

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

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

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

@@ -0,0 +1,16 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import { type SourceFile, type SourceImport } from '../SourceFile.js';
+import { FunctionType } from './FunctionType.js';
+import type { GetCodeOptions, Type, TypeKind } from './Type.js';
+export declare class PromiseType implements Type {
+    readonly resultingType: Type;
+    readonly errorType: Type;
+    constructor(resultingType: Type);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    get resolverFunction(): FunctionType;
+    get rejecterFunction(): FunctionType;
+    getCode(language: Language, options?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

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

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

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

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

package/lib/syntax/types/StringType.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 StringType implements Type {
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

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

@@ -0,0 +1,14 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import { type FileWithReferencedTypes, type SourceFile, type SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, NamedType, Type, TypeKind } from './Type.js';
+export declare class StructType implements Type {
+    readonly structName: string;
+    readonly properties: NamedType[];
+    readonly declarationFile: FileWithReferencedTypes;
+    constructor(structName: string, properties: NamedType[]);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    getCode(language: Language, { fullyQualified }?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

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

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

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

@@ -0,0 +1,55 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from '../SourceFile.js';
+export type TypeKind = 'array-buffer' | 'array' | 'bigint' | 'boolean' | 'custom-type' | 'enum' | 'error' | 'function' | 'hybrid-object' | 'hybrid-object-base' | 'map' | 'null' | 'number' | 'optional' | 'promise' | 'record' | 'string' | 'struct' | 'tuple' | 'variant' | 'result-wrapper' | 'date' | 'void';
+export interface GetCodeOptions {
+    /**
+     * Specifies whether the name (e.g. a C++ class name)
+     * should use the fully qualified namespace name prefix.
+     */
+    fullyQualified?: boolean;
+}
+/**
+ * Represents a TypeScript Type that can be represented in a native language (C++, Swift, Kotlin)
+ */
+export interface Type {
+    /**
+     * Get whether this type can be passed by reference in C++ (`const T&` vs `T`)
+     */
+    readonly canBePassedByReference: boolean;
+    /**
+     * Get the kind of the type.
+     */
+    readonly kind: TypeKind;
+    /**
+     * Get the native code required to represent this type for the given language (C++, Swift, Kotlin).
+     *
+     * E.g. for a `number` type, this would return `'double'` in C++.
+     *
+     * The `options` parameter can specify custom options. Subclasses may have more options.
+     */
+    getCode(language: Language, options?: GetCodeOptions): string;
+    /**
+     * Get all required extra files that need to be **created** for this type to properly work.
+     *
+     * E.g. for `type Gender = 'male' | 'female'`, the enum `Gender` needs to be created first (as a separate file).
+     */
+    getExtraFiles(): SourceFile[];
+    /**
+     * Get all required extra imports that need to be **imported** for this type to properly work.
+     */
+    getRequiredImports(language: Language): SourceImport[];
+}
+export interface NamedType extends Type {
+    /**
+     * Get the name of the value if it is a member or parameter.
+     *
+     * E.g. for a class member `double _something`, this returns `'_something'`.
+     */
+    readonly name: string;
+    /**
+     * Get the name of the value escaped as a valid C++ variable name.
+     *
+     * E.g. for a class member `double some-value`, this returns `'some_value'`.
+     */
+    readonly escapedName: string;
+}

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

@@ -0,0 +1,19 @@
+import type { Language } from '../../getPlatformSpecs.js';
+import { type SourceFile, type SourceImport } from '../SourceFile.js';
+import type { GetCodeOptions, Type, TypeKind } from './Type.js';
+export declare const VariantLabels: readonly ["first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eigth", "ninth", "tenth"];
+type VariantLabel = (typeof VariantLabels)[number];
+export declare class VariantType implements Type {
+    readonly variants: Type[];
+    readonly aliasName?: string;
+    constructor(variants: Type[], aliasName?: string);
+    get canBePassedByReference(): boolean;
+    get kind(): TypeKind;
+    get jsType(): string;
+    get cases(): [VariantLabel, Type][];
+    getAliasName(language: Language, options?: GetCodeOptions): string;
+    getCode(language: Language, options?: GetCodeOptions): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}
+export {};