chore: Add generated types

packages/base64/atob.d.ts

@@ -0,0 +1,2 @@
+export function atob(encodedData: string): string;
+//# sourceMappingURL=atob.d.ts.map

packages/base64/btoa.d.ts

@@ -0,0 +1,2 @@
+export function btoa(stringToEncode: string): string;
+//# sourceMappingURL=btoa.d.ts.map

packages/base64/decode.d.ts

@@ -0,0 +1,2 @@
+export { decodeBase64 } from "./src/decode.js";
+//# sourceMappingURL=decode.d.ts.map

packages/base64/encode.d.ts

@@ -0,0 +1,2 @@
+export { encodeBase64 } from "./src/encode.js";
+//# sourceMappingURL=encode.d.ts.map

packages/base64/index.d.ts

@@ -0,0 +1,5 @@
+export { encodeBase64 } from "./src/encode.js";
+export { decodeBase64 } from "./src/decode.js";
+export { btoa } from "./btoa.js";
+export { atob } from "./atob.js";
+//# sourceMappingURL=index.d.ts.map

packages/base64/shim.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=shim.d.ts.map

packages/base64/src/common.d.ts

@@ -0,0 +1,11 @@
+export const padding: "=";
+export const alphabet64: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/**
+ * The numeric value corresponding to each letter of the alphabet.
+ * If an alphabet is named for the Greek letters alpha and beta, then clearly a
+ * monodu is named for the corresponding Greek numbers mono and duo.
+ *
+ * @type {Record<string, number>}
+ */
+export const monodu64: Record<string, number>;
+//# sourceMappingURL=common.d.ts.map

packages/base64/src/decode.d.ts

@@ -0,0 +1,4 @@
+export function jsDecodeBase64(string: string, name?: string | undefined): Uint8Array;
+/** @type {typeof jsDecodeBase64} */
+export const decodeBase64: typeof jsDecodeBase64;
+//# sourceMappingURL=decode.d.ts.map

packages/base64/src/encode.d.ts

@@ -0,0 +1,4 @@
+export function jsEncodeBase64(data: Uint8Array): string;
+/** @type {typeof jsEncodeBase64} */
+export const encodeBase64: typeof jsEncodeBase64;
+//# sourceMappingURL=encode.d.ts.map

packages/bundle-source/cache.d.ts

@@ -0,0 +1,54 @@
+export namespace jsOpts {
+    function encodeBundle(bundle: any): string;
+    function toBundleName(n: any): string;
+    function toBundleMeta(n: any): string;
+}
+export namespace jsonOpts {
+    export function encodeBundle_1(bundle: any): string;
+    export { encodeBundle_1 as encodeBundle };
+    export function toBundleName_1(n: any): string;
+    export { toBundleName_1 as toBundleName };
+    export function toBundleMeta_1(n: any): string;
+    export { toBundleMeta_1 as toBundleMeta };
+}
+export function makeBundleCache(wr: any, cwd: any, readPowers: any, opts: any): {
+    add: (rootPath: any, targetName: any, log?: any) => Promise<BundleMeta>;
+    validate: (targetName: string, rootOpt: any, log?: Logger | undefined, meta?: BundleMeta | undefined) => Promise<BundleMeta>;
+    validateOrAdd: (rootPath: string, targetName: string, log?: Logger | undefined) => Promise<BundleMeta>;
+    load: (rootPath: string, targetName?: string | undefined, log?: Logger | undefined) => Promise<any>;
+};
+export function makeNodeBundleCache(dest: string, options: {
+    format?: string;
+    cacheOpts?: CacheOpts;
+    cacheSourceMaps?: boolean;
+    dev?: boolean;
+    log?: Logger;
+}, loadModule: (id: string) => Promise<any>, pid?: number | undefined, nonce?: number | undefined): Promise<{
+    add: (rootPath: any, targetName: any, log?: any) => Promise<BundleMeta>;
+    validate: (targetName: string, rootOpt: any, log?: Logger | undefined, meta?: BundleMeta | undefined) => Promise<BundleMeta>;
+    validateOrAdd: (rootPath: string, targetName: string, log?: Logger | undefined) => Promise<BundleMeta>;
+    load: (rootPath: string, targetName?: string | undefined, log?: Logger | undefined) => Promise<any>;
+}>;
+/**
+ * A message logger.
+ */
+export type Logger = (...args: unknown[]) => void;
+export type BundleMeta = {
+    bundleFileName: string;
+    /**
+     * ISO format
+     */
+    bundleTime: string;
+    bundleSize: number;
+    moduleSource: {
+        relative: string;
+        absolute: string;
+    };
+    contents: Array<{
+        relativePath: string;
+        mtime: string;
+        size: number;
+    }>;
+};
+export type CacheOpts = typeof jsOpts;
+//# sourceMappingURL=cache.d.ts.map

packages/bundle-source/src/bundle-source.d.ts

@@ -0,0 +1,4 @@
+export default bundleSource;
+/** @type {import('./types').BundleSource} */
+declare const bundleSource: import('./types').BundleSource;
+//# sourceMappingURL=bundle-source.d.ts.map

packages/bundle-source/src/fs.d.ts

@@ -0,0 +1,47 @@
+export function makeFileReader(fileName: string, { fs, path }: {
+    fs: {
+        promises: Pick<typeof import("fs/promises"), 'readFile' | 'stat'>;
+    };
+    path: Pick<import("path").PlatformPath, 'resolve' | 'relative' | 'normalize'>;
+}): {
+    toString: () => string;
+    readText: () => Promise<string>;
+    maybeReadText: () => Promise<string | undefined>;
+    neighbor: (ref: any) => any;
+    stat: () => Promise<import("fs").Stats>;
+    absolute: () => string;
+    relative: (there: any) => string;
+    exists: () => Promise<boolean>;
+};
+/**
+ * @param {string} fileName
+ * @param {{
+ *   fs: Pick<import('fs'), 'existsSync'> &
+ *     { promises: Pick<
+ *         import('fs/promises'),
+ *         'readFile' | 'stat' | 'writeFile' | 'mkdir' | 'rename' | 'rm'
+ *       >,
+ *     },
+ *   path: Pick<import('path'), 'dirname' | 'resolve' | 'relative' | 'normalize'>,
+ * }} io
+ * @param {(there: string) => ReturnType<makeFileWriter>} make
+ */
+export const makeFileWriter: any;
+/**
+ * @param {string} fileName
+ * @param {{
+ *   fs: Pick<import('fs'), 'existsSync'> &
+ *     { promises: Pick<
+ *         import('fs/promises'),
+ *         'readFile' | 'stat' | 'writeFile' | 'mkdir' | 'rm'
+ *       >,
+ *     },
+ *   path: Pick<import('path'), 'resolve' | 'relative' | 'normalize'>,
+ *   os: Pick<import('os'), 'platform'>,
+ * }} io
+ * @param {number} [pid]
+ * @param {number} [nonce]
+ * @param {(there: string) => ReturnType<makeAtomicFileWriter>} make
+ */
+export const makeAtomicFileWriter: any;
+//# sourceMappingURL=fs.d.ts.map

packages/bundle-source/src/index.d.ts

@@ -0,0 +1,4 @@
+export default bundleSource;
+export * from "./exports.js";
+import bundleSource from './bundle-source.js';
+//# sourceMappingURL=index.d.ts.map

packages/bundle-source/src/is-entrypoint.d.ts

@@ -0,0 +1,2 @@
+export function isEntrypoint(href: any): boolean;
+//# sourceMappingURL=is-entrypoint.d.ts.map

packages/bundle-source/src/main.d.ts

@@ -0,0 +1,6 @@
+export function main(args: [to: string, dest: string, ...rest: string[]], { loadModule, pid, log }: {
+    loadModule: (spec: string) => any;
+    pid: number;
+    log?: import("../cache.js").Logger | undefined;
+}): Promise<void>;
+//# sourceMappingURL=main.d.ts.map

packages/bundle-source/src/nested-evaluate-and-get-exports.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @template {'nestedEvaluate' | 'getExport'} T
+ * @param {string} startFilename
+ * @param {T} moduleFormat
+ * @param {any} powers
+ */
+export function bundleNestedEvaluateAndGetExports<T extends "nestedEvaluate" | "getExport">(startFilename: string, moduleFormat: T, powers: any): Promise<{
+    moduleFormat: T;
+    source: string;
+    sourceMap: string;
+}>;
+//# sourceMappingURL=nested-evaluate-and-get-exports.d.ts.map

packages/bundle-source/src/tool.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=tool.d.ts.map

packages/bundle-source/src/types.d.ts

@@ -0,0 +1,43 @@
+export type ModuleFormat = 'endoZipBase64' | 'nestedEvaluate' | 'getExport';
+export type BundleSource = BundleSourceSimple & BundleSourceWithFormat & BundleSourceWithOptions & BundleSourceGeneral;
+export type BundleSourceResult<T extends ModuleFormat> = T extends 'endoZipBase64' ? {
+    moduleFormat: 'endoZipBase64';
+    endoZipBase64: string;
+    endoZipBase64Sha512: string;
+} : T extends 'getExport' | 'nestedEvaluate' ? {
+    moduleFormat: T;
+    source: string;
+    sourceMap: string;
+} : never;
+export type BundleSourceSimple = <T extends "endoZipBase64">(startFilename: string) => Promise<BundleSourceResult<T>>;
+export type BundleSourceWithFormat = <T extends ModuleFormat = "endoZipBase64">(startFilename: string, format: T, powers?: {
+    read?: ReadFn;
+    canonical?: CanonicalFn;
+    externals?: string[];
+}) => Promise<BundleSourceResult<T>>;
+export type BundleSourceWithOptions = <T extends ModuleFormat = "endoZipBase64">(startFilename: string, bundleOptions: BundleOptions<T>, powers?: {
+    read?: ReadFn;
+    canonical?: CanonicalFn;
+    externals?: string[];
+}) => Promise<BundleSourceResult<T>>;
+export type BundleSourceGeneral = <T extends ModuleFormat = "endoZipBase64">(startFilename: string, formatOrOptions?: T | BundleOptions<T> | undefined, powers?: {
+    read?: ReadFn;
+    canonical?: CanonicalFn;
+    externals?: string[];
+}) => Promise<BundleSourceResult<T>>;
+export type BundleOptions<T extends ModuleFormat> = {
+    format?: T | undefined;
+    /**
+     * - development mode, for test bundles that need
+     * access to devDependencies of the entry package.
+     */
+    dev?: boolean | undefined;
+};
+export type ReadFn = (location: string) => Promise<Uint8Array>;
+/**
+ * Returns a canonical URL for a given URL, following redirects or symbolic
+ * links if any exist along the path.
+ * Must return the given logical location if the real location does not exist.
+ */
+export type CanonicalFn = (location: string) => Promise<string>;
+//# sourceMappingURL=types.d.ts.map

packages/bundle-source/src/zip-base64.d.ts

@@ -0,0 +1,6 @@
+export function bundleZipBase64(startFilename: any, options?: {}, grantedPowers?: {}): Promise<{
+    moduleFormat: "endoZipBase64";
+    endoZipBase64: string;
+    endoZipBase64Sha512: string;
+}>;
+//# sourceMappingURL=zip-base64.d.ts.map

packages/captp/src/atomics.d.ts

@@ -0,0 +1,6 @@
+export const MIN_DATA_BUFFER_LENGTH: 1;
+export const TRANSFER_OVERHEAD_LENGTH: number;
+export const MIN_TRANSFER_BUFFER_LENGTH: number;
+export function makeAtomicsTrapHost(transferBuffer: SharedArrayBuffer): import('./types.js').TrapHost;
+export function makeAtomicsTrapGuest(transferBuffer: SharedArrayBuffer): import('./types.js').TrapGuest;
+//# sourceMappingURL=atomics.d.ts.map

packages/captp/src/captp.d.ts

@@ -0,0 +1,52 @@
+export { E };
+export function makeCapTP(ourId: string, rawSend: (obj: Record<string, any>) => void, bootstrapObj?: any, opts?: CapTPOptions): {
+    abort: (reason?: undefined) => void;
+    dispatch: (obj: any) => boolean;
+    getBootstrap: () => Promise<any>;
+    getStats: () => {
+        send: {
+            [x: string]: number;
+        };
+        recv: {
+            [x: string]: number;
+        };
+        gc: {
+            DROPPED: number;
+        };
+    };
+    isOnlyLocal: (specimen: any) => boolean;
+    serialize: import("@endo/marshal").ToCapData<string>;
+    unserialize: import("@endo/marshal").FromCapData<string>;
+    makeTrapHandler: (name: any, obj: any) => any;
+    Trap: import('./ts-types.js').Trap | undefined;
+};
+/**
+ * the options to makeCapTP
+ */
+export type CapTPOptions = {
+    exportHook?: ((val: unknown, slot: import('./types.js').CapTPSlot) => void) | undefined;
+    importHook?: ((val: unknown, slot: import('./types.js').CapTPSlot) => void) | undefined;
+    onReject?: ((err: any) => void) | undefined;
+    /**
+     * an integer tag to attach to all messages in order to
+     * assist in ignoring earlier defunct instance's messages
+     */
+    epoch?: number | undefined;
+    /**
+     * if specified, enable this CapTP (guest) to
+     * use Trap(target) to block while the recipient (host) resolves and
+     * communicates the response to the message
+     */
+    trapGuest?: import("./types.js").TrapGuest | undefined;
+    /**
+     * if specified, enable this CapTP (host) to serve
+     * objects marked with makeTrapHandler to synchronous clients (guests)
+     */
+    trapHost?: import("./types.js").TrapHost | undefined;
+    /**
+     * if true, aggressively garbage collect imports
+     */
+    gcImports?: boolean | undefined;
+};
+import { E } from '@endo/eventual-send';
+//# sourceMappingURL=captp.d.ts.map

packages/captp/src/finalize.d.ts

@@ -0,0 +1,13 @@
+export function makeFinalizingMap<K, V extends unknown>(finalizer?: ((key: K) => void) | undefined, opts?: {
+    weakValues?: boolean | undefined;
+} | undefined): Pick<Map<K, V>, "get" | "has" | "delete"> & {
+    set: (key: K, value: V) => void;
+    clearWithoutFinalizing: () => void;
+    getSize: () => number;
+} & import("@endo/eventual-send").RemotableBrand<{}, FinalizingMap<K, V>>;
+export type FinalizingMap<K, V extends unknown> = Pick<Map<K, V>, 'get' | 'has' | 'delete'> & {
+    set: (key: K, value: V) => void;
+    clearWithoutFinalizing: () => void;
+    getSize: () => number;
+};
+//# sourceMappingURL=finalize.d.ts.map