nitrogen 0.29.8 → 0.30.0

package/lib/Logger.d.ts

@@ -0,0 +1,10 @@
+export type LogLevel = 'debug' | 'info' | 'warning' | 'error';
+export declare function isValidLogLevel(level: unknown): level is LogLevel;
+export declare function setLogLevel(level: LogLevel): void;
+export declare const Logger: {
+    withIndented(callback: () => void): void;
+    debug(message: string, ...extra: unknown[]): void;
+    info(message: string, ...extra: unknown[]): void;
+    warn(message: string, ...extra: unknown[]): void;
+    error(message: string, ...extra: unknown[]): void;
+};

package/lib/autolinking/Autolinking.d.ts

@@ -0,0 +1,8 @@
+import type { Platform } from '../getPlatformSpecs.js';
+import type { SourceFile } from '../syntax/SourceFile.js';
+type AutolinkingFile = Omit<SourceFile, 'language'>;
+export interface Autolinking {
+    platform: Platform;
+    sourceFiles: AutolinkingFile[];
+}
+export {};

package/lib/autolinking/android/createCMakeExtension.d.ts

@@ -0,0 +1,6 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+export interface CMakeFile extends Omit<SourceFile, 'language'> {
+    language: 'cmake';
+}
+export declare function getBuildingWithGeneratedCmakeDefinition(): string;
+export declare function createCMakeExtension(files: SourceFile[]): CMakeFile;

package/lib/autolinking/android/createGradleExtension.d.ts

@@ -0,0 +1,5 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+export interface GradleFile extends Omit<SourceFile, 'language'> {
+    language: 'gradle';
+}
+export declare function createGradleExtension(): GradleFile;

package/lib/autolinking/android/createHybridObjectInitializer.d.ts

@@ -0,0 +1,2 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+export declare function createHybridObjectIntializer(): SourceFile[];

package/lib/autolinking/createAndroidAutolinking.d.ts

@@ -0,0 +1,11 @@
+import type { SourceFile, SourceImport } from '../syntax/SourceFile.js';
+import type { Autolinking } from './Autolinking.js';
+interface JNIHybridRegistration {
+    sourceImport: SourceImport;
+    registrationCode: string;
+}
+interface AndroidAutolinking extends Autolinking {
+    jniHybridRegistrations: JNIHybridRegistration[];
+}
+export declare function createAndroidAutolinking(allFiles: SourceFile[]): AndroidAutolinking;
+export {};

package/lib/autolinking/createIOSAutolinking.d.ts

@@ -0,0 +1,5 @@
+import type { Autolinking } from './Autolinking.js';
+interface IOSAutolinking extends Autolinking {
+}
+export declare function createIOSAutolinking(): IOSAutolinking;
+export {};

package/lib/autolinking/ios/createHybridObjectInitializer.d.ts

@@ -0,0 +1,9 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+type ObjcFile = Omit<SourceFile, 'language'> & {
+    language: 'objective-c++';
+};
+type SwiftFile = Omit<SourceFile, 'language'> & {
+    language: 'swift';
+};
+export declare function createHybridObjectIntializer(): [ObjcFile, SwiftFile] | [];
+export {};

package/lib/autolinking/ios/createPodspecRubyExtension.d.ts

@@ -0,0 +1,5 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+export interface RubyFile extends Omit<SourceFile, 'language'> {
+    language: 'ruby';
+}
+export declare function createPodspecRubyExtension(): RubyFile;

package/lib/autolinking/ios/createSwiftCxxBridge.d.ts

@@ -0,0 +1,2 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+export declare function createSwiftCxxBridge(): SourceFile[];

package/lib/autolinking/ios/createSwiftUmbrellaHeader.d.ts

@@ -0,0 +1,3 @@
+import type { SourceFile } from '../../syntax/SourceFile.js';
+export declare function getUmbrellaHeaderName(): string;
+export declare function createSwiftUmbrellaHeader(): SourceFile;

package/lib/config/NitroConfig.d.ts

@@ -0,0 +1,52 @@
+import type { NitroUserConfig } from './NitroUserConfig.js';
+/**
+ * Represents the properly parsed `nitro.json` config of the current executing directory.
+ */
+export declare class NitroConfig {
+    private readonly config;
+    private static singleton;
+    constructor(config: NitroUserConfig);
+    static get current(): NitroConfig;
+    /**
+     * Returns the name of the Android C++ library (aka name in CMakeLists.txt `add_library(..)`).
+     * This will be loaded via `System.loadLibrary(...)`.
+     * @example `NitroTest`
+     */
+    getAndroidCxxLibName(): string;
+    /**
+     * Returns the iOS module name (aka Pod name) of the module that will be generated.
+     * @example `NitroTest`
+     */
+    getIosModuleName(): string;
+    /**
+     * Represents the C++ namespace of the module that will be generated.
+     * This can have multiple sub-namespaces, and is always relative to `margelo::nitro`.
+     * @example `['image']` -> `margelo::nitro::image`
+     */
+    getCxxNamespace(language: 'c++' | 'swift', ...subDefinitionName: string[]): string;
+    /**
+     * Represents the Android namespace of the module that will be generated.
+     * This can have multiple sub-namespaces, and is always relative to `com.margelo.nitro`.
+     * @example `['image']` -> `com.margelo.nitro.image`
+     */
+    getAndroidPackage(language: 'java/kotlin' | 'c++/jni', ...subPackage: string[]): string;
+    /**
+     * Return the directory of the android package, and a given sub-package.
+     * This will be used on android to put files from a package in their respective package folder.
+     */
+    getAndroidPackageDirectory(...subPackage: string[]): string[];
+    /**
+     * Get the autolinking configuration of all HybridObjects.
+     * Those will be generated and default-constructed.
+     */
+    getAutolinkedHybridObjects(): NitroUserConfig['autolinking'];
+    /**
+     * Get the paths that will be ignored when loading the TypeScript project.
+     * In most cases, this just contains `node_modules/`.
+     */
+    getIgnorePaths(): string[];
+    getGitAttributesGeneratedFlag(): boolean;
+    get isExternalConfig(): boolean;
+    getSwiftBridgeHeaderName(): string;
+    getSwiftBridgeNamespace(language: 'c++' | 'swift'): string;
+}

package/lib/config/NitroUserConfig.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export declare const NitroUserConfigSchema: z.ZodObject<{
+    cxxNamespace: z.ZodArray<z.ZodString>;
+    ios: z.ZodObject<{
+        iosModuleName: z.ZodString;
+    }, z.core.$strip>;
+    android: z.ZodObject<{
+        androidNamespace: z.ZodArray<z.ZodString>;
+        androidCxxLibName: z.ZodString;
+    }, z.core.$strip>;
+    autolinking: z.ZodRecord<z.ZodString, z.ZodObject<{
+        cpp: z.ZodOptional<z.ZodString>;
+        swift: z.ZodOptional<z.ZodString>;
+        kotlin: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    ignorePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    gitAttributesGeneratedFlag: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+/**
+ * Represents the structure of a `nitro.json` config file.
+ */
+export type NitroUserConfig = z.infer<typeof NitroUserConfigSchema>;

package/lib/config/getConfig.d.ts

@@ -0,0 +1,2 @@
+import { type NitroUserConfig } from './NitroUserConfig.js';
+export declare function readUserConfig(configPath: string): NitroUserConfig;

package/lib/createGitAttributes.d.ts

@@ -0,0 +1 @@
+export declare function createGitAttributes(markAsGenerated: boolean, folder: string): Promise<string>;

package/lib/createPlatformSpec.d.ts

@@ -0,0 +1,4 @@
+import { Type } from 'ts-morph';
+import type { SourceFile } from './syntax/SourceFile.js';
+import { type Language } from './getPlatformSpecs.js';
+export declare function generatePlatformFiles(interfaceType: Type, language: Language): SourceFile[];

package/lib/getFiles.d.ts

@@ -0,0 +1 @@
+export declare function getFiles(directory: string): Promise<string[]>;

package/lib/getPlatformSpecs.d.ts

@@ -0,0 +1,17 @@
+import type { PlatformSpec } from 'react-native-nitro-modules';
+import type { InterfaceDeclaration, Type, TypeAliasDeclaration } from 'ts-morph';
+export type Platform = keyof Required<PlatformSpec>;
+export type Language = Required<PlatformSpec>[keyof PlatformSpec];
+export declare function isDirectlyHybridObject(type: Type): boolean;
+export declare function extendsHybridObject(type: Type, recursive: boolean): boolean;
+export declare function isHybridViewProps(type: Type): boolean;
+export declare function isHybridViewMethods(type: Type): boolean;
+export declare function isHybridView(type: Type): boolean;
+export declare function isAnyHybridSubclass(type: Type): boolean;
+/**
+ * If the given interface ({@linkcode declaration}) extends `HybridObject`,
+ * this method returns the platforms it exists on.
+ * If it doesn't extend `HybridObject`, this returns `undefined`.
+ */
+export declare function getHybridObjectPlatforms(declaration: InterfaceDeclaration | TypeAliasDeclaration): PlatformSpec | undefined;
+export declare function getHybridViewPlatforms(view: InterfaceDeclaration | TypeAliasDeclaration): PlatformSpec | undefined;

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/init.d.ts

@@ -0,0 +1 @@
+export declare function initNewNitroModule(baseDirectory: string, moduleName: string, ref?: string): Promise<void>;

package/lib/nitrogen.d.ts

@@ -0,0 +1,11 @@
+interface NitrogenOptions {
+    baseDirectory: string;
+    outputDirectory: string;
+}
+interface NitrogenResult {
+    generatedFiles: string[];
+    targetSpecsCount: number;
+    generatedSpecsCount: number;
+}
+export declare function runNitrogen({ baseDirectory, outputDirectory, }: NitrogenOptions): Promise<NitrogenResult>;
+export {};

package/lib/prettifyDirectory.d.ts

@@ -0,0 +1 @@
+export declare function prettifyDirectory(directory: string): string;

package/lib/syntax/BridgedType.d.ts

@@ -0,0 +1,41 @@
+import type { Language } from '../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from './SourceFile.js';
+import type { Type } from './types/Type.js';
+export interface BridgedType<FromLanguage extends Language, ToLanguage extends Language> {
+    /**
+     * The underlying type that is being bridged between {@linkcode FromLanguage} and {@linkcode ToLanguage}
+     */
+    readonly type: Type;
+    /**
+     * Whether the underlying type has a valid type (is not void or null)
+     */
+    readonly hasType: boolean;
+    /**
+     * Whether this type can be passed by reference
+     */
+    readonly canBePassedByReference: boolean;
+    /**
+     * Whether this bridged type needs special handling, or can just be used as-is
+     */
+    readonly needsSpecialHandling: boolean;
+    /**
+     * Get all imports required for this bridge to work
+     */
+    getRequiredImports(language: Language): SourceImport[];
+    /**
+     * Get all extra files that need to be created for this type, as well as the bridge.
+     */
+    getExtraFiles(): SourceFile[];
+    /**
+     * Get the code for the type itself in the given language
+     */
+    getTypeCode(language: FromLanguage | ToLanguage): string;
+    /**
+     * Parse the given parameter from the source language to the given target language, in the given language.
+     * For example, to convert an ArrayBuffer from Swift ({@linkcode from}) to C++ ({@linkcode to}) we
+     * have to wrap it in an ArrayBufferHolder in Swift ({@linkcode inLanguage}), and unwrap
+     * it from the ArrayBufferHolder again in C++ ({@linkcode inLanguage})
+     */
+    parse(parameterName: string, from: FromLanguage, to: ToLanguage, inLanguage: FromLanguage | ToLanguage): string;
+    parse(parameterName: string, from: ToLanguage, to: FromLanguage, inLanguage: FromLanguage | ToLanguage): string;
+}

package/lib/syntax/CodeNode.d.ts

@@ -0,0 +1,23 @@
+import type { Language } from '../getPlatformSpecs.js';
+import type { SourceFile, SourceImport } from './SourceFile.js';
+export interface CodeNode {
+    /**
+     * Get the code of this code node (e.g. property, method) in the given language.
+     */
+    getCode(language: Language): string;
+    /**
+     * Get all extra definition files this code node needs (e.g. extra type/struct declarations
+     * for complex types), or `[]` if none are required (e.g. if this uses primitive types only)
+     *
+     * All files returned here must be created in the project.
+     * To include them, see {@linkcode getRequiredImports | getRequiredImports()}
+     */
+    getExtraFiles(): SourceFile[];
+    /**
+     * Get all required imports this code node needs (e.g. extra type/struct declarations for complex types),
+     * or `[]` if no imports are required (e.g. if this uses primitive types only).
+     *
+     * All imports returned here must be included in the current file (e.g. `#include "..."` or `import ...`)
+     */
+    getRequiredImports(language: Language): SourceImport[];
+}

package/lib/syntax/Method.d.ts

@@ -0,0 +1,41 @@
+import type { CodeNode } from './CodeNode.js';
+import type { Language } from '../getPlatformSpecs.js';
+import { type SourceFile, type SourceImport } from './SourceFile.js';
+import { Parameter } from './Parameter.js';
+import type { Type } from './types/Type.js';
+export type MethodBody = string;
+export interface MethodModifiers {
+    /**
+     * The name of the class that defines this C++ method.
+     * Example: `Person` -> `void Person::sayHi()`
+     */
+    classDefinitionName?: string;
+    /**
+     * Whether the function should be marked as inlineable.
+     */
+    inline?: boolean;
+    virtual?: boolean;
+    /**
+     * Whether the function is marked as `noexcept` (doesn't throw) or not.
+     */
+    noexcept?: boolean;
+    /**
+     * Whether this function overrides a base/super function.
+     */
+    override?: boolean;
+    /**
+     * Whether this method has a `@DoNotStrip` and `@Keep` attribute to avoid
+     * it from being stripped from the binary by the Java compiler or ProGuard.
+     */
+    doNotStrip?: boolean;
+}
+export declare class Method implements CodeNode {
+    readonly name: string;
+    readonly returnType: Type;
+    readonly parameters: Parameter[];
+    constructor(name: string, returnType: Type, parameters: Parameter[]);
+    get jsSignature(): string;
+    getCode(language: Language, modifiers?: MethodModifiers, body?: MethodBody): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

package/lib/syntax/Parameter.d.ts

@@ -0,0 +1,15 @@
+import type { ParameterDeclaration } from 'ts-morph';
+import type { CodeNode } from './CodeNode.js';
+import type { Language } from '../getPlatformSpecs.js';
+import { type SourceFile, type SourceImport } from './SourceFile.js';
+import type { NamedType, Type } from './types/Type.js';
+export declare class Parameter implements CodeNode {
+    readonly type: NamedType;
+    constructor(name: string, type: Type);
+    constructor(parameter: ParameterDeclaration, language: Language);
+    get jsSignature(): string;
+    get name(): string;
+    getCode(language: Language): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+}

package/lib/syntax/Property.d.ts

@@ -0,0 +1,50 @@
+import type { CodeNode } from './CodeNode.js';
+import { type SourceFile, type SourceImport } from './SourceFile.js';
+import type { Language } from '../getPlatformSpecs.js';
+import type { Type } from './types/Type.js';
+import { Method } from './Method.js';
+export interface PropertyBody {
+    getter: string;
+    setter: string;
+}
+export type LanguageEnvironment = 'jvm' | 'swift' | 'other';
+export interface PropertyModifiers {
+    /**
+     * The name of the class that defines this C++ property getter/setter method.
+     * Example: `Person` -> `int Person::getAge()`
+     */
+    classDefinitionName?: string;
+    /**
+     * Whether the property should be marked as inlineable.
+     */
+    inline?: boolean;
+    virtual?: boolean;
+    /**
+     * Whether the property is marked as `noexcept` (doesn't throw) or not.
+     */
+    noexcept?: boolean;
+    /**
+     * Whether this property overrides a base/super property.
+     */
+    override?: boolean;
+    /**
+     * Whether this property has a `@DoNotStrip` and `@Keep` attribute to avoid
+     * it from being stripped from the binary by the Java compiler or ProGuard.
+     */
+    doNotStrip?: boolean;
+}
+export declare class Property implements CodeNode {
+    readonly name: string;
+    readonly type: Type;
+    readonly isReadonly: boolean;
+    constructor(name: string, type: Type, isReadonly: boolean);
+    get jsSignature(): string;
+    getExtraFiles(): SourceFile[];
+    getRequiredImports(language: Language): SourceImport[];
+    getGetterName(environment: LanguageEnvironment): string;
+    getSetterName(environment: LanguageEnvironment): string;
+    get cppGetter(): Method;
+    get cppSetter(): Method | undefined;
+    getCppMethods(): [getter: Method] | [getter: Method, setter: Method];
+    getCode(language: Language, modifiers?: PropertyModifiers, body?: PropertyBody): string;
+}

package/lib/syntax/SourceFile.d.ts

@@ -0,0 +1,70 @@
+import type { Language, Platform } from '../getPlatformSpecs.js';
+import type { Type } from './types/Type.js';
+/**
+ * Represents a file with source code, in a specific programming language.
+ */
+export interface SourceFile {
+    /**
+     * The name of the file with extension (e.g. `Image.hpp`)
+     */
+    name: string;
+    /**
+     * The subdirectory/subdirectories of the file, or empty (`[]`) if none.
+     */
+    subdirectory: string[];
+    /**
+     * The full content of the file.
+     */
+    content: string;
+    /**
+     * The language the {@linkcode content} is written in (e.g. `c++`)
+     */
+    language: Language;
+    /**
+     * The platform this file can be used on or is created for. (e.g. `ios`)
+     */
+    platform: Platform | 'shared';
+}
+/**
+ * Represents a {@linkcode SourceFile} that also references other types.
+ */
+export interface FileWithReferencedTypes extends SourceFile {
+    /**
+     * All external types this {@linkcode SourceFile} references,
+     * either as return types, parameter types, or member types.
+     */
+    referencedTypes: Type[];
+}
+/**
+ * Represents an import for a specific header or module.
+ *
+ * E.g. `include "Image.hpp"`, or `import NitroModules`
+ */
+export interface SourceImport {
+    /**
+     * The name of the header or module to import (e.g. `Image.hpp`)
+     */
+    name: string;
+    /**
+     * If this is a C++ import, it could also be forward-declared.
+     * @example
+     * ```cpp
+     * namespace NitroTest {
+     *   class HybridImage;
+     * }
+     * ```
+     */
+    forwardDeclaration?: string;
+    /**
+     * The language this file is written in (e.g. `c++`)
+     */
+    language: Language;
+    /**
+     * Whether the import is a user-defined header (something local, like `"MyObject.hpp"`)
+     * or a shared system header (like `<NitroModules/HybridObject.hpp>`)
+     */
+    space: 'user' | 'system';
+}
+type GroupedFiles = Record<SourceFile['platform'], SourceFile[]>;
+export declare function groupByPlatform(files: SourceFile[]): GroupedFiles;
+export {};

package/lib/syntax/c++/CppEnum.d.ts

@@ -0,0 +1,6 @@
+import type { SourceFile } from '../SourceFile.js';
+import type { EnumMember } from '../types/EnumType.js';
+/**
+ * Creates a C++ enum that converts to a JS enum (aka just int)
+ */
+export declare function createCppEnum(typename: string, enumMembers: EnumMember[]): SourceFile;

package/lib/syntax/c++/CppHybridObject.d.ts

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

package/lib/syntax/c++/CppHybridObjectRegistration.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 C++ class that will be default-constructed
+     */
+    cppClassName: string;
+}
+interface CppHybridObjectRegistration {
+    cppCode: string;
+    requiredImports: SourceImport[];
+}
+export declare function createCppHybridObjectRegistration({ hybridObjectName, cppClassName, }: Props): CppHybridObjectRegistration;
+export {};

package/lib/syntax/c++/CppStruct.d.ts

@@ -0,0 +1,3 @@
+import type { FileWithReferencedTypes } from '../SourceFile.js';
+import type { NamedType } from '../types/Type.js';
+export declare function createCppStruct(typename: string, properties: NamedType[]): FileWithReferencedTypes;

package/lib/syntax/c++/CppStruct.js

@@ -48,6 +48,7 @@ ${createFileMetadataString(`${typename}.hpp`)}
 
 ${includeNitroHeader('JSIConverter.hpp')}
 ${includeNitroHeader('NitroDefines.hpp')}
+${includeNitroHeader('JSIHelpers.hpp')}
 
 ${cppForwardDeclarations.join('\n')}
 
@@ -90,6 +91,9 @@ namespace margelo::nitro {
         return false;
       }
       jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
       ${indent(cppCanConvertCalls, '      ')}
       return true;
     }

package/lib/syntax/c++/CppUnion.d.ts

@@ -0,0 +1,6 @@
+import type { SourceFile } from '../SourceFile.js';
+import type { EnumMember } from '../types/EnumType.js';
+/**
+ * Creates a C++ enum that converts to a TypeScript union (aka just strings).
+ */
+export declare function createCppUnion(typename: string, enumMembers: EnumMember[]): SourceFile;

package/lib/syntax/c++/getForwardDeclaration.d.ts

@@ -0,0 +1,3 @@
+type DeclarationKind = 'class' | 'struct' | 'enum class';
+export declare function getForwardDeclaration(kind: DeclarationKind, className: string, namespace?: string): string;
+export {};

package/lib/syntax/c++/includeNitroHeader.d.ts

@@ -0,0 +1,7 @@
+import type { SourceImport } from '../SourceFile.js';
+/**
+ * Generates C++ code for including a `NitroModules` header.
+ * @example `Hash.hpp` -> `#include <NitroModules/Hash.hpp>`
+ */
+export declare function includeNitroHeader(headerName: string): string;
+export declare function includeHeader(sourceImport: SourceImport, force?: boolean): string;

package/lib/syntax/createType.d.ts

@@ -0,0 +1,15 @@
+import { Type as TSMorphType } from 'ts-morph';
+import type { Type } from './types/Type.js';
+import { NamedWrappingType } from './types/NamedWrappingType.js';
+import { type Language } from '../getPlatformSpecs.js';
+export declare function createNamedType(language: Language, name: string, type: TSMorphType, isOptional: boolean): NamedWrappingType<Type>;
+export declare function createVoidType(): Type;
+/**
+ * Get a list of all currently known complex types.
+ */
+export declare function getAllKnownTypes(language?: Language): Type[];
+export declare function addKnownType(key: string, type: Type, language: Language): void;
+/**
+ * Create a new type (or return it from cache if it is already known)
+ */
+export declare function createType(language: Language, type: TSMorphType, isOptional: boolean): Type;

package/lib/syntax/getAllTypes.d.ts

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

package/lib/syntax/getCustomTypeConfig.d.ts

@@ -0,0 +1,8 @@
+import type { CustomTypeConfig } from 'react-native-nitro-modules';
+import type { Type as TSMorphType } from 'ts-morph';
+interface Result {
+    name: string;
+    config: CustomTypeConfig;
+}
+export declare function getCustomTypeConfig(type: TSMorphType): Result;
+export {};

package/lib/syntax/getInterfaceProperties.d.ts

@@ -0,0 +1,4 @@
+import type { ts, Type } from 'ts-morph';
+import type { NamedType } from './types/Type.js';
+import type { Language } from '../getPlatformSpecs.js';
+export declare function getInterfaceProperties(language: Language, interfaceType: Type<ts.ObjectType>): NamedType[];

package/lib/syntax/getReferencedTypes.d.ts

@@ -0,0 +1,2 @@
+import type { Type } from './types/Type.js';
+export declare function getReferencedTypes(type: Type): Type[];

package/lib/syntax/helpers.d.ts

@@ -0,0 +1,13 @@
+import type { SourceFile } from './SourceFile.js';
+import type { Type } from './types/Type.js';
+type Comment = '///' | '#';
+export declare function createFileMetadataString(filename: string, comment?: Comment): string;
+export declare function isFunction(type: Type): boolean;
+export declare function toReferenceType(type: string): `const ${typeof type}&`;
+export declare function escapeCppName(string: string): string;
+export declare function isBooleanPropertyPrefix(name: string): boolean;
+export declare function isNotDuplicate<T>(item: T, index: number, array: T[]): boolean;
+export declare function isCppFile(file: SourceFile): boolean;
+export declare function getRelativeDirectory(file: SourceFile): string;
+export declare function getRelativeDirectoryGenerated(...subpath: string[]): string;
+export {};

package/lib/syntax/isCoreType.d.ts

@@ -0,0 +1,9 @@
+import { Type as TSMorphType } from 'ts-morph';
+export declare function isPromise(type: TSMorphType): boolean;
+export declare function isRecord(type: TSMorphType): boolean;
+export declare function isArrayBuffer(type: TSMorphType): boolean;
+export declare function isDate(type: TSMorphType): boolean;
+export declare function isMap(type: TSMorphType): boolean;
+export declare function isError(type: TSMorphType): boolean;
+export declare function isCustomType(type: TSMorphType): boolean;
+export declare function isSyncFunction(type: TSMorphType): boolean;

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

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

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

@@ -0,0 +1,8 @@
+import type { SourceImport } from '../SourceFile.js';
+export interface JNINativeRegistration {
+    namespace: string;
+    className: string;
+    import: SourceImport;
+}
+export declare function addJNINativeRegistration(registerFunc: JNINativeRegistration): void;
+export declare function getJNINativeRegistrations(): JNINativeRegistration[];

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;