akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/types/vendor/@akanjs/native/packages/cli/src/lib/native-plugins.d.ts

@@ -0,0 +1,67 @@
+import type { PluginDecl } from "../../../core/src/index.ts";
+import type { PlistValue } from "./plist.ts";
+import type { AndroidManifest, IosManifest, ResolvedPlugin } from "./project.ts";
+export type NativePlatform = "macos" | "windows" | "linux" | "ios" | "android";
+/** Declarations for boot.json: how this platform provides each plugin. */
+export declare function pluginDecls(plugins: ResolvedPlugin[], platform: NativePlatform): Record<string, PluginDecl>;
+/**
+ * A desktop module against its manifest: the page is told the methods and events of the manifest
+ * (or its `desktop` subset), and the host answers NOT_FOUND for any the module lacks: a `$listen`
+ * of an event without a source, a method that is not there. Imports the module (it only defines
+ * the plugin; setup runs in the app).
+ */
+export declare function desktopModuleProblems(plugin: ResolvedPlugin): Promise<string[]>;
+export interface NativePlugin<M> {
+    plugin: ResolvedPlugin;
+    native: M;
+    /** Absolute source files. */
+    sources: string[];
+}
+/**
+ * A file a manifest names, which must be inside the plugin's folder: relative, no "..", and its real
+ * location (through symbolic links) inside the folder's (N7). A plugin cannot compile someone
+ * else's files into the app.
+ */
+export declare function pluginFile(plugin: ResolvedPlugin, relativePath: string, what: string): string;
+export declare function iosPlugins(plugins: ResolvedPlugin[]): NativePlugin<IosManifest>[];
+export declare function androidPlugins(plugins: ResolvedPlugin[]): NativePlugin<AndroidManifest>[];
+/**
+ * Writes the Swift / Kotlin bindings of the plugins with "codegen": true into `dir` (emptied first,
+ * so a plugin that stops opting in leaves nothing behind) and returns the files (PL-10).
+ */
+export declare function writePluginBindings(plugins: NativePlugin<unknown>[], platform: "ios" | "android", dir: string, appDir: string): string[];
+export declare function swiftRegistry(plugins: NativePlugin<IosManifest>[]): string;
+/** A plugin's `android.minSdk`, checked: at least the app's, at most the SDK akan-native compiles against. */
+export declare function pluginMinSdk(id: string, native: AndroidManifest, appMinSdk: number, compileSdk: number): number;
+/**
+ * AkanNativeFeatures.kt: the shell's optional parts as constants (architecture review stage 6). The shell
+ * reaches them only under these; kotlinc drops the branches of a false constant and R8 the classes
+ * nothing reaches, so a release build without updates carries no update code.
+ */
+export declare function kotlinFeatures(features: {
+    dev: boolean;
+    updates: boolean;
+}): string;
+export declare function kotlinRegistry(plugins: NativePlugin<AndroidManifest>[], appMinSdk: number, compileSdk: number): string;
+/**
+ * The app's Info.plist (O5-1, architecture review F): akan-native's own keys (`base`), each plugin's entries,
+ * then the app last: its permission texts (C8), usageDescriptions overrides of keys that are there,
+ * and native.ios.infoPlist. Arrays union, dictionaries merge, two plugins that disagree on a value
+ * fail the build, and `owned` keys only akan-native sets.
+ */
+export declare function iosInfoPlist(plugins: NativePlugin<IosManifest>[], overrides: Record<string, string>, appEntries?: Record<string, string>, opts?: {
+    base?: Record<string, PlistValue>;
+    app?: Record<string, PlistValue>;
+    owned?: string[];
+}): Record<string, PlistValue>;
+/**
+ * The app's entitlements: akan-native's, each plugin's, associated-domains for deepLinks.domains, then
+ * native.ios.entitlements. Xcode's variables in string values are filled in: $(AppIdentifierPrefix)
+ * and $(TeamIdentifierPrefix) with "<team id>." ("" on the simulator), $(PRODUCT_BUNDLE_IDENTIFIER).
+ */
+export declare function iosEntitlements(bundleId: string, plugins: NativePlugin<IosManifest>[], domains: {
+    host: string;
+}[], app?: Record<string, PlistValue>, teamId?: string): Record<string, PlistValue>;
+export declare function iosFrameworks(plugins: NativePlugin<IosManifest>[]): string[];
+export declare function androidPermissions(plugins: NativePlugin<AndroidManifest>[], appPermissions?: string[]): string[];
+export declare function describeSources(appDir: string, plugins: NativePlugin<unknown>[]): string;

package/types/vendor/@akanjs/native/packages/cli/src/lib/nativeconfig.d.ts

@@ -0,0 +1,11 @@
+import type { PlistValue } from "./plist.ts";
+export interface PlistSource {
+    /** For error messages: "the shell", "plugin push", "the app (native.ios.infoPlist)". */
+    who: string;
+    values: Record<string, PlistValue | undefined>;
+}
+/**
+ * Merges `sources` in order under the rules above; `final` (the app) wins over them without an
+ * error, but may not touch `owned` keys. Throws a CliError listing every conflict.
+ */
+export declare function mergePlist(sources: PlistSource[], final?: PlistSource, owned?: string[]): Record<string, PlistValue>;

package/types/vendor/@akanjs/native/packages/cli/src/lib/permissions.d.ts

@@ -0,0 +1,10 @@
+export declare const PERMISSION_NAMES: readonly ["camera", "microphone", "location"];
+export type PermissionName = (typeof PERMISSION_NAMES)[number];
+/** `true` uses a generic usage text; a string is the text iOS and macOS show. */
+export type PermissionsConfig = Partial<Record<PermissionName, string | true>>;
+export declare function validatePermissions(raw: unknown): PermissionsConfig;
+/** Info.plist usage descriptions for the declared permissions. */
+export declare function permissionPlist(config: PermissionsConfig, platform: "ios" | "macos"): Record<string, string>;
+export declare function androidPermissionsFor(config: PermissionsConfig): string[];
+/** `<uses-feature … android:required="false"/>` lines for the declared permissions. */
+export declare function androidFeaturesFor(config: PermissionsConfig): string[];

package/types/vendor/@akanjs/native/packages/cli/src/lib/plist.d.ts

@@ -0,0 +1,11 @@
+export type PlistValue = string | number | boolean | Date | PlistValue[] | {
+    [key: string]: PlistValue | undefined;
+};
+export declare function toPlist(root: {
+    [key: string]: PlistValue | undefined;
+}): string;
+/**
+ * Reads an XML property list (what `security cms -D` prints for a provisioning profile). <data> comes
+ * back as its base64 text (whitespace removed), <date> as a Date.
+ */
+export declare function parsePlist(xml: string): PlistValue;

package/types/vendor/@akanjs/native/packages/cli/src/lib/png.d.ts

@@ -0,0 +1,11 @@
+/** 8-bit RGBA, not premultiplied, rows top to bottom. */
+export interface Image {
+    width: number;
+    height: number;
+    data: Uint8Array;
+}
+export declare class PngError extends Error {
+}
+export declare function decodePng(bytes: Uint8Array): Image;
+/** 8-bit RGBA PNG (RGB when fully opaque). Each row gets the filter with the smallest sum of |bytes|. */
+export declare function encodePng(image: Image): Uint8Array;

package/types/vendor/@akanjs/native/packages/cli/src/lib/prepare.d.ts

@@ -0,0 +1,138 @@
+import type { Platform } from "../../../core/src/index.ts";
+import { CliError } from "./log.ts";
+import { type Project } from "./project.ts";
+/**
+ * debug: inspectable webview, dev signing, runtime env overrides, the dev server (akan-native run, dev,
+ * test). release: none of that (akan-native build, update publish). Independent of `mode`, which only
+ * picks the .env files, so a staging build is still a release build.
+ */
+export type BuildProfile = "debug" | "release";
+export interface BuildOptions {
+    mode: string;
+    profile: BuildProfile;
+    /** Skip `web.build` and use what is already in web.dir. */
+    skipWebBuild: boolean;
+    /**
+     * `akan-native dev --hmr`: the dev gateway the native host fetches pages from instead of its bundled
+     * files (lib/hmr.ts). Ignored by release builds, which never contain it.
+     */
+    devServer?: string;
+    /** Default <app>/.akan/native/build/<platform>. */
+    outDir?: string;
+    /**
+     * Dev builds: the path and query of the first page (akanjs readiness O4-5), e.g.
+     * "/en/?csr=true&akanMobileTarget=default". Release builds always start at "/".
+     */
+    startPath?: string;
+    /** false: no .env files (docs/api.md envFiles). Default true. */
+    envFiles?: boolean;
+    /** PUBLIC_ values above every other source (docs/api.md env). */
+    env?: Record<string, string>;
+    /**
+     * Called through the programmatic API (docs/api.md): nothing is written into the app folder (no
+     * akan-native-env.d.ts), and signing comes only from the options, never from AKAN_NATIVE_ANDROID_* or
+     * AKAN_NATIVE_IOS_* variables.
+     */
+    api?: boolean;
+    /** Android release output (akanjs readiness O1-5). */
+    android?: AndroidRelease;
+    /** iOS devices (akanjs readiness O1-2, O1-3). */
+    ios?: IosBuild;
+}
+/** Which identity and profile an iOS device build signs with; unset: found in the keychain and Xcode's profiles. */
+export interface IosSigning {
+    /** A certificate name ("Apple Development: …") or its SHA-1. Default: found (docs/api.md §3). */
+    identity?: string;
+    /** A .mobileprovision file. Default: the fitting local profile (docs/api.md §3). */
+    provisioningProfile?: string;
+    /** Only this team's profiles (when several teams have one for the app). */
+    teamId?: string;
+    /** Release builds: an App Store profile (default) or, only when asked for, an ad hoc one. */
+    distribution?: "app-store" | "ad-hoc";
+}
+/** What an iPhone build was signed with (BuildResult.signing), for the caller to show. */
+export interface IosSigningResult {
+    identity: string;
+    identitySha1: string;
+    profile: string;
+    profileUuid: string;
+    teamId: string;
+    kind: string;
+    /** ISO date. */
+    expires: string;
+}
+export interface IosBuild {
+    /** An iPhone build (iphoneos, signed with a certificate and a profile) instead of the simulator's. Release builds also get an .ipa. */
+    device?: boolean;
+    signing?: IosSigning;
+    /** The iPhone this build is installed on (run, dev): a development or ad hoc profile must list its UDID. */
+    target?: {
+        udid: string;
+        name?: string;
+    };
+}
+/** An upload or release key in a keystore (JKS or PKCS12). The passwords never reach a command line. */
+export interface AndroidSigning {
+    keystore: string;
+    alias: string;
+    storePassword: string;
+    /** Default the store password (PKCS12 keystores have one password). */
+    keyPassword?: string;
+}
+export interface AndroidRelease {
+    /** Release builds only; without it they are signed with ~/.akan/native/debug.keystore (with a warning). */
+    signing?: AndroidSigning;
+    /** Also build an App Bundle (.aab), signed with the same key. */
+    bundle?: boolean;
+}
+/** The release key is missing or does not sign (AkanNativeError SIGNING_FAILED). */
+/** Signing failed; `problems`: the candidates, or why each profile did not fit. */
+export declare class SigningError extends CliError {
+    readonly problems: string[];
+    constructor(message: string, problems?: string[]);
+}
+export interface BuildContext {
+    project: Project;
+    platform: Platform;
+    mode: string;
+    profile: BuildProfile;
+    /** profile === "debug" */
+    dev: boolean;
+    /** <app>/.akan/native/build/<platform> */
+    outDir: string;
+    /** Absolute web.dir */
+    webDir: string;
+    /** index.html with the init script injected */
+    html: string;
+    env: Record<string, string>;
+    /** Dev builds only: see BuildOptions.devServer. The native builders write it to shell.json. */
+    devServer?: string;
+    /** Dev builds only: see BuildOptions.startPath. */
+    startPath?: string;
+    android?: AndroidRelease;
+    ios?: IosBuild;
+    /** Artifacts besides the one the builder returns (an .aab next to the .apk). */
+    artifacts: {
+        kind: "aab" | "ipa";
+        path: string;
+    }[];
+    /** What the builder signed with, when it signs (Android: the app's release key or the debug key). */
+    signedAs?: "debug" | "development" | "distribution";
+    /** Called through the API (BuildOptions.api). */
+    api: boolean;
+    /** Android builds with pinned libraries: the license notices file written next to the app (BuildResult.licenses). */
+    licenses?: string;
+    /** iPhone builds: the identity and profile they were signed with. */
+    iosSigning?: IosSigningResult;
+}
+/** A dev start path: a path on the app's origin, not one of akan-native's (/__akan_native/*). */
+export declare function checkStartPath(path: string): string;
+/** The app's own web build failed (AkanNativeError WEB_BUILD_FAILED). */
+export declare class WebBuildError extends CliError {
+}
+/** web.dir cannot be used as it is (AkanNativeError WEB_INPUT_INVALID). */
+export declare class WebInputError extends CliError {
+}
+export declare function prepare(project: Project, platform: Platform, options: BuildOptions): Promise<BuildContext>;
+/** https, or http to this machine (a local test server, `akan-native update serve`). */
+export declare function secureUpdateUrl(url: string): boolean;

package/types/vendor/@akanjs/native/packages/cli/src/lib/privacy.d.ts

@@ -0,0 +1,13 @@
+import type { AkanNativeConfig } from "../config.ts";
+import type { PlistValue } from "./plist.ts";
+/** The categories Apple lists, without the NSPrivacyAccessedAPICategory prefix. */
+export declare const PRIVACY_API_CATEGORIES: readonly ["FileTimestamp", "SystemBootTime", "DiskSpace", "ActiveKeyboards", "UserDefaults"];
+export interface PrivacySource {
+    /** Who declares it, for error messages ("plugin filesystem", "the app"). */
+    who: string;
+    apis: Record<string, string[]> | undefined;
+}
+/** Problems with a category → reasons map. */
+export declare function privacyApiProblems({ who, apis }: PrivacySource): string[];
+/** PrivacyInfo.xcprivacy's root dictionary: every declared category once, reasons merged and sorted. */
+export declare function privacyManifest(sources: PrivacySource[], privacy?: AkanNativeConfig["privacy"]): Record<string, PlistValue>;

package/types/vendor/@akanjs/native/packages/cli/src/lib/project.d.ts

@@ -0,0 +1,208 @@
+import type { AkanNativeConfig } from "../config.ts";
+import { type PermissionSet } from "./acl.ts";
+import { type EnvConfig } from "./env.ts";
+import { CliError } from "./log.ts";
+import { type PermissionsConfig } from "./permissions.ts";
+import type { PlistValue } from "./plist.ts";
+import { type UpdatesConfig } from "./updates.ts";
+export interface ResolvedConfig extends Omit<AkanNativeConfig, "icon" | "splash" | "permissions" | "updates"> {
+    app: Required<AkanNativeConfig["app"]>;
+    web: Required<Pick<AkanNativeConfig["web"], "dir" | "base">> & {
+        build?: string;
+        devEntry?: string;
+    };
+    plugins: string[];
+    env: EnvConfig;
+    shell: {
+        backgroundColor: string;
+        backgroundColorDark: string;
+    };
+    usageDescriptions: Record<string, string>;
+    permissions: PermissionsConfig;
+    deepLinks: {
+        schemes: string[];
+        domains: {
+            host: string;
+            pathPrefixes: string[];
+        }[];
+    };
+    desktop: {
+        quitOnLastWindowClosed: boolean;
+    };
+    updates: UpdatesConfig | null;
+    /** Absolute image path. */
+    icon: {
+        image: string;
+        backgroundColor?: string;
+    } | null;
+    splash: {
+        backgroundColor: string;
+        backgroundColorDark: string;
+        image?: string;
+        autoHide: boolean;
+        timeout: number;
+    };
+}
+export interface Project {
+    appDir: string;
+    /** The config file, or "the config" when an API caller passed the object (docs/api.md). */
+    configPath: string;
+    config: ResolvedConfig;
+    plugins: ResolvedPlugin[];
+}
+export declare function findAppDir(from: string): string;
+export declare function loadProject(appDir: string): Promise<Project>;
+export interface ProjectOptions {
+    /** For messages. Default "the config". */
+    configPath?: string;
+    /** Where plugin package names resolve from. Default the app folder. Relative plugin folders always use the app folder. */
+    resolveFrom?: string;
+}
+/** Invalid config values, all of them at once (AkanNativeError CONFIG_INVALID carries the list). */
+export declare class ConfigError extends CliError {
+    readonly problems: string[];
+    constructor(where: string, problems: string[]);
+}
+/**
+ * Why a display name cannot be a folder or shortcut name on every OS, or null (Dioxus #5743,
+ * Electrobun #514: names like "My App." or "A/B" broke installs).
+ */
+export declare function appNameProblem(name: unknown): string | null;
+/**
+ * What each target accepts as the build number (app.build, `--build`, AKAN_NATIVE_BUILD), or null: a positive
+ * integer; Android's versionCode goes to 2,100,000,000; Windows puts it in a version resource field
+ * (at most 65535); Apple takes any positive integer as CFBundleVersion.
+ */
+export declare function buildNumberProblem(build: unknown, platform: string): string | null;
+/** The last part of the app id, lowercased: "com.example.Notes" → "notes". */
+export declare function defaultFileName(id: string): string;
+export declare function projectFromConfig(raw: AkanNativeConfig, appDir: string, options?: ProjectOptions): Project;
+export interface NativeSubset {
+    /** Methods this platform implements. Default: all of the manifest's methods. */
+    methods?: string[];
+    events?: string[];
+    /** The methods and events not listed run the plugin's web implementation instead of being UNSUPPORTED. */
+    web?: boolean;
+}
+export interface IosManifest extends NativeSubset {
+    /** Swift files, relative to the plugin folder. Globs allowed. */
+    sources: string[];
+    /** Swift class conforming to AkanNativePlugin. */
+    class: string;
+    frameworks?: string[];
+    /** Info.plist entries, typically usage descriptions. The app config may override the texts. */
+    infoPlist?: Record<string, PlistValue>;
+    /**
+     * Required Reason APIs the plugin's code calls (App Store privacy manifest), by category without the
+     * NSPrivacyAccessedAPICategory prefix, e.g. { "UserDefaults": ["CA92.1"] }. Merged into
+     * PrivacyInfo.xcprivacy (lib/privacy.ts).
+     */
+    privacyApis?: Record<string, string[]>;
+    /** Entitlements the plugin's feature needs (e.g. aps-environment), merged like Info.plist entries. */
+    entitlements?: Record<string, PlistValue>;
+}
+export interface AndroidManifest extends NativeSubset {
+    /** Kotlin or Java files, relative to the plugin folder. Globs allowed. */
+    sources: string[];
+    /** Fully qualified class with a constructor (AkanNativePluginContext). */
+    class: string;
+    permissions?: string[];
+    /** Extra XML inserted into <application> (e.g. a <provider>). ${applicationId} is replaced. */
+    applicationXml?: string;
+    /** Extra XML at the <manifest> level (e.g. <queries> for package visibility). ${applicationId} is replaced. */
+    manifestXml?: string;
+    /** Extra R8 rules for release builds. Components named in applicationXml are kept automatically. */
+    proguard?: string[];
+    /**
+     * Pinned Maven libraries the plugin needs (akanjs readiness O8), as root coordinates, e.g.
+     * "com.android.billingclient:billing:9.1.0". Their closure comes from native/android/maven.lock.json
+     * and goes only into apps that use the plugin.
+     */
+    maven?: string[];
+    /**
+     * The lowest Android API the plugin runs on, when it is above the app's (e.g. 35 for sqlite, built on
+     * SQLiteRawStatement). Below it the plugin is not created and every call is UNSUPPORTED; its package
+     * may use APIs up to this level without version checks (apilevel.ts).
+     */
+    minSdk?: number;
+}
+/** Desktop Bun module that implements only some methods (the rest are UNSUPPORTED, or web with `web: true`). */
+export interface DesktopManifest extends NativeSubset {
+    module: string;
+}
+export interface PluginManifest {
+    id: string;
+    apiVersion: 1;
+    /** The JS API surface. Native implementations must handle all of them. */
+    methods: string[];
+    events: string[];
+    web?: string | null;
+    /**
+     * Per platform: "web" = the web implementation runs in the app's WebView,
+     * native description = native implementation, null or missing = unsupported.
+     * desktop takes a path to a Bun module (run in the desktop Worker) as its native form.
+     */
+    desktop?: "web" | string | DesktopManifest | null;
+    /** macOS packaging extras, e.g. usage descriptions needed by a "web" desktop implementation. */
+    macos?: {
+        infoPlist?: Record<string, PlistValue>;
+    };
+    ios?: IosManifest | "web" | null;
+    android?: AndroidManifest | "web" | null;
+    /**
+     * PL-11. What "<id>:default" grants: local permission names (allow-<method>,
+     * allow-listen-<event>, set names, "all"). Absent: every method and event.
+     */
+    defaultPermissions?: string[];
+    /** Named permission sets, e.g. { read: { permissions: ["allow-readFile", "allow-stat"] } } → "<id>:read". */
+    permissionSets?: Record<string, PermissionSet>;
+    /** The scope fields the plugin enforces, with a description each, e.g. { path: "glob relative to base" }. */
+    /** `urlFields`: the fields that hold URL patterns (matched by urlMatch; the build checks their denies). */
+    scope?: {
+        description?: string;
+        fields: Record<string, string>;
+        urlFields?: string[];
+        pathFields?: string[];
+    };
+    /**
+     * Scopes of `<plugin>:default`, which an app without `capabilities` gets: what the plugin allows
+     * without the app asking (filesystem: the app's own folders; http: no URL). A capability's own
+     * `allow` on `<plugin>:default` replaces these; its `deny` is added.
+     */
+    defaultScope?: {
+        allow?: Record<string, string>[];
+        deny?: Record<string, string>[];
+    };
+    /**
+     * PL-10: generate Swift / Kotlin types and a `<Plugin>PluginSpec` protocol from the
+     * definePlugin<Api, Events> interfaces in src/index.ts into every iOS and Android build.
+     */
+    codegen?: boolean;
+    /**
+     * Plugins whose native code this plugin's native code uses (architecture review stage 6). Each must
+     * be in the app's plugins (akan-native never adds one by itself) and have a native part wherever this one does.
+     */
+    dependencies?: string[];
+    /**
+     * Events whose payload is a snapshot (progress, a size, a position): the host sends only the latest
+     * of a burst, at most about every 100 ms (architecture review stage 4). The payload must be
+     * cumulative or absolute, never a delta; an end state is a method's result, not an event.
+     */
+    coalesce?: string[];
+}
+export interface ResolvedPlugin {
+    /** What the app config listed. */
+    spec: string;
+    dir: string;
+    manifest: PluginManifest;
+}
+export declare function resolvePlugins(appDir: string, specs: string[], resolveFrom?: string): ResolvedPlugin[];
+/** Keys akan-native does not know, at the top and in the platform entries ("ios.bogus"). A typo would otherwise do nothing. */
+export declare function unknownManifestKeys(manifest: object): string[];
+/**
+ * Plugins whose native part needs another plugin's native part on this platform (dependencies):
+ * the other one must not be web-only or missing there.
+ */
+export declare function dependencyProblems(plugins: ResolvedPlugin[], platform: string): string[];
+/** Why a resource's logical `to` is not allowed, or null. */
+export declare function resourceTargetProblem(to: string): string | null;

package/types/vendor/@akanjs/native/packages/cli/src/lib/root.d.ts

@@ -0,0 +1 @@
+export declare const PACKAGE_ROOT: string;

package/types/vendor/@akanjs/native/packages/cli/src/lib/routes.d.ts

@@ -0,0 +1 @@
+export { isHostPath, type Route, route as routeRequest } from "../../../core/src/kernel.ts";

package/types/vendor/@akanjs/native/packages/cli/src/lib/serve.d.ts

@@ -0,0 +1,17 @@
+export interface ServeOptions {
+    dir: string;
+    port: number;
+    hostname?: string;
+    /** Replaces the built __akan_native/init.js (runtime env overrides). */
+    initScript?: () => string;
+    /** akan-native dev: serve a reload channel and append its client to init.js. */
+    liveReload?: LiveReload;
+}
+/** Server-sent events that tell open pages to reload (akan-native dev web). */
+export declare class LiveReload {
+    private clients;
+    response(): Response;
+    reload(): void;
+    static readonly CLIENT = ";(function(){try{var s=new EventSource('/__akan_native/dev/events');s.onmessage=function(){location.reload()}}catch(e){}})();\n";
+}
+export declare function serveApp({ dir, port, hostname, initScript, liveReload }: ServeOptions): Bun.Server<undefined>;

package/types/vendor/@akanjs/native/packages/cli/src/lib/signing.d.ts

@@ -0,0 +1,14 @@
+export interface SigningIdentity {
+    /** SHA-1 of the certificate, what `codesign --sign` takes. */
+    hash: string;
+    name: string;
+}
+export declare const identityName: () => string;
+/** Valid (trusted) code-signing identities in the keychains. */
+export declare function validIdentities(): Promise<SigningIdentity[]>;
+/** The identity `akan-native signing setup` made, if it is still valid; null means ad-hoc signing. */
+export declare function devIdentity(env?: NodeJS.ProcessEnv): Promise<SigningIdentity | null>;
+export declare function setupSigning(): Promise<{
+    identity: SigningIdentity;
+    created: boolean;
+}>;

package/types/vendor/@akanjs/native/packages/cli/src/lib/spec.d.ts

@@ -0,0 +1,96 @@
+export type TypeNode = {
+    kind: "string" | "number" | "boolean" | "unknown" | "void";
+} | {
+    kind: "literal";
+    values: string[];
+} | {
+    kind: "array";
+    of: TypeNode;
+} | {
+    kind: "record";
+    of: TypeNode;
+} | {
+    kind: "object";
+    fields: Field[];
+} | {
+    kind: "ref";
+    name: string;
+} | {
+    kind: "nullable";
+    of: TypeNode;
+}
+/** `A & { b: string }`: the generators merge the object parts (as react-native-codegen flattens them). */
+ | {
+    kind: "intersection";
+    of: TypeNode[];
+}
+/** A union with named members (`"any" | OrientationType`): fine when every member is a string union. */
+ | {
+    kind: "union";
+    of: TypeNode[];
+} | {
+    kind: "unsupported";
+    text: string;
+    reason: string;
+};
+export interface Field {
+    name: string;
+    type: TypeNode;
+    optional: boolean;
+    doc?: string;
+}
+export interface Method {
+    name: string;
+    doc?: string;
+    /** The single argument object, if the method takes one. */
+    param?: {
+        name: string;
+        type: TypeNode;
+        optional: boolean;
+    };
+    /** What the Promise resolves to (void for none). */
+    returns: TypeNode;
+}
+export type Declaration = {
+    kind: "interface";
+    name: string;
+    doc?: string;
+    extends: string[];
+    fields: Field[];
+    methods: Method[];
+} | {
+    kind: "alias";
+    name: string;
+    doc?: string;
+    type: TypeNode;
+};
+export interface PluginSpec {
+    /** The file the spec was read from. */
+    file: string;
+    api: string;
+    events?: string;
+    methods: Method[];
+    /** Event name → payload type, from the Events interface (the second definePlugin type argument). */
+    eventTypes: Field[];
+    /** Declarations of the file, for resolving refs. */
+    declarations: Map<string, Declaration>;
+}
+/** @akanjs/native/core types plugin specs may use. */
+export declare const BUILTIN_TYPES: Record<string, Declaration>;
+/** Top-level interfaces and type aliases of a TS file, and the type arguments of definePlugin<…>. */
+export declare function parseDeclarations(source: string): {
+    declarations: Map<string, Declaration>;
+    imports: string[];
+    definePlugin?: {
+        api: string;
+        events?: string;
+    };
+};
+/** Resolves a ref to its declaration: the file's own, then @akanjs/native/core's. */
+export declare function lookup(spec: Pick<PluginSpec, "declarations">, name: string): Declaration | undefined;
+/** All fields of an interface, including the ones it extends (parents first). */
+export declare function interfaceFields(spec: Pick<PluginSpec, "declarations">, decl: Extract<Declaration, {
+    kind: "interface";
+}>, seen?: Set<string>): Field[];
+/** Reads the spec of a plugin: the definePlugin<Api, Events> interfaces in src/index.ts. */
+export declare function readPluginSpec(pluginDir: string, file?: string): PluginSpec;