@astrale-os/cli 1.0.0-beta.9 → 1.0.0-npm-deprecated.0

package/dist/types/admin/binding.d.ts

@@ -1,19 +0,0 @@
-import type { Input } from '@astrale-os/sdk/client';
-import type { ClientSession } from '@astrale-os/sdk/client/session';
-import type { ResolvedClass, ResolvedProperty } from '@astrale-os/sdk/schema';
-import type { DomainBinding } from '@astrale-os/shell';
-import { Path } from '@astrale-os/sdk/graph/path';
-export type AdminBinding = DomainBinding;
-/** Bind the exact Admin revision installed on this source Kernel. */
-export declare function bindAdmin(session: ClientSession): Promise<AdminBinding>;
-/** Admit an injected dynamic binding as the Admin Domain. */
-export declare function requireAdminBinding(binding: AdminBinding): AdminBinding;
-/** Resolve one required Admin Class without rebuilding its schema contract. */
-export declare function requireAdminClass(binding: AdminBinding, name: string, kind: 'node'): ResolvedClass<'node'>;
-export declare function requireAdminClass(binding: AdminBinding, name: string, kind: 'edge'): ResolvedClass<'edge'>;
-/** Resolve one required Admin Core Node as its canonical projection Path. */
-export declare function requireAdminCore(binding: AdminBinding, name: string): Path;
-/** Resolve one effective Property by unambiguous member name. */
-export declare function requireAdminProperty(owner: ResolvedClass, name: string): ResolvedProperty<unknown>;
-/** Invoke one resolved executable instance Method through Kernel Client. */
-export declare function invokeAdminMethod(session: ClientSession, binding: AdminBinding, owner: ResolvedClass<'node'>, name: string, receiver: Path, input: Input): Promise<unknown>;

package/dist/types/admin/instance/client.d.ts

@@ -1,22 +0,0 @@
-import type { ClientSession } from '@astrale-os/sdk/client/session';
-import { type AdminBinding } from '../binding';
-import { type DomainInstallReceipt, type InstanceInfo, type OwnedInstanceInfo } from './model';
-export interface AdminInstanceContext {
-    readonly session: ClientSession;
-}
-export interface AdminInstanceApi {
-    list(): Promise<OwnedInstanceInfo[]>;
-    create(slug: string): Promise<InstanceInfo>;
-    status(identifier: string): Promise<InstanceInfo>;
-    delete(identifier: string): Promise<InstanceInfo>;
-    installDomain(identifier: string, domain: string): Promise<DomainInstallReceipt>;
-}
-export interface AdminInstanceDependencies {
-    readonly bind?: (session: ClientSession) => Promise<AdminBinding>;
-    readonly operationId?: (kind: 'create' | 'status' | 'delete' | 'install-domain') => string;
-}
-/**
- * Bind one discovered Admin root revision and expose only the public Instance
- * product journey. No Host lifecycle method is present on this capability.
- */
-export declare function connectAdminInstances(context: AdminInstanceContext, dependencies?: AdminInstanceDependencies): Promise<AdminInstanceApi>;

package/dist/types/admin/instance/index.d.ts

@@ -1,2 +0,0 @@
-export { connectAdminInstances, type AdminInstanceApi, type AdminInstanceContext, type AdminInstanceDependencies, } from './client';
-export { AdminInstanceNotFoundError, findOwnedInstance, formatInstanceState, type DomainInstallReceipt, type InstanceInfo, type InstanceState, type OwnedInstanceInfo, } from './model';

package/dist/types/admin/instance/model.d.ts

@@ -1,33 +0,0 @@
-/** CLI-stable projection of one caller-visible Admin Instance. */
-export type InstanceState = 'provisioning' | 'ready' | 'deleting' | 'failed' | 'deleted';
-export interface InstanceInfo {
-    readonly id: string;
-    readonly slug: string;
-    readonly url: string;
-    readonly state: InstanceState;
-    readonly phase?: string;
-    readonly error?: string | null;
-    readonly createdAt?: string;
-    readonly organizationId?: string;
-}
-/** An Instance returned through the caller-scoped Admin graph inventory. */
-export interface OwnedInstanceInfo extends InstanceInfo {
-    readonly state: InstanceState;
-}
-export interface DomainInstallReceipt {
-    readonly domain: string;
-    readonly instance: string;
-    readonly origin: string;
-    readonly ok: boolean;
-    readonly installedRevision?: string;
-    readonly error?: string;
-}
-export declare class AdminInstanceNotFoundError extends AstraleError {
-    readonly identifier: string;
-    constructor(identifier: string);
-}
-/** Match an owner-scoped Instance by slug, canonical Node Path, or bare Node id. */
-export declare function findOwnedInstance(instances: readonly OwnedInstanceInfo[], identifier: string): OwnedInstanceInfo | undefined;
-/** Human-readable non-ready lifecycle state for one Instance. */
-export declare function formatInstanceState(info: InstanceInfo): string;
-import { AstraleError } from '../../errors';

package/dist/types/connect-core.d.ts

@@ -1,22 +0,0 @@
-/**
- * Temporary compatibility surface for the observed `@astrale-os/connect-host`
- * consumer. Keep this file as re-exports only: CLI state and connection owners
- * remain authoritative, and no Kernel Client implementation type is exposed.
- */
-export { getDefault, getIdentity, readIdentities } from './identity/registry';
-export type { Identity, IdentityStore } from './identity/registry';
-export { listIdentityKeys, signAs } from './keys/index';
-export { normalizeInstanceKernelUrl, orgIdForAudience, readInstances, resetInstancesMemo, resolveInstance, } from './lib/instance';
-export type { InstanceEntry, InstanceStore, ResolvedInstance } from './lib/instance';
-export { resolveInstanceTarget } from './lib/instance-target';
-export type { ResolvedInstanceTarget } from './lib/instance-target';
-export { readConfig } from './lib/config';
-export type { AstraleConfig } from './lib/config';
-export { IdpOrgMembershipError, IdpRefreshTransientError, resolveCredential, } from './connection/auth';
-export { loginViaIdp, resolveIdpName } from './lib/login-flow';
-export type { DeviceVerification, LoginFlowOpts, LoginResult } from './lib/login-flow';
-export { isSessionExpired, readIdpSession } from './lib/idp';
-export type { IdpSession } from './lib/idp';
-export { AuthError } from './errors';
-export { fetchWithCaFile } from './lib/ca-fetch';
-export { createPaths, paths } from './state/index';

package/dist/types/connection/auth.d.ts

@@ -1,39 +0,0 @@
-import type { AstraleConfig } from '../lib/config';
-import type { ConnectionOptions, ConnectionTarget } from './target';
-import { type Identity } from '../identity/registry';
-import { IdpAudienceMismatchError } from '../lib/idp';
-import { IdpSessionNoRefreshTokenError } from '../lib/idp-session';
-export type KeyIdentityAuthOptions = {
-    issuer: string;
-    subject?: string;
-    audience: string;
-};
-/** Pin the local identity label before a session performs any authenticated effect. */
-export declare function bindCredentialIdentity<Options extends ConnectionOptions>(options: Options, target: ConnectionTarget): Promise<Options>;
-/**
- * Resolve a signed JWT credential from CLI options.
- *
- * The **audience** is passed in explicitly by the caller because transport URL
- * and kernel issuer can differ for remote deployments.
- *
- * Three cases, in order of priority:
- *   1. `opts.creds` — pre-signed credential, returned as-is.
- *   2. `opts.as` — sign as a named local identity.
- *   3. Default — sign as the active local identity. If the identity has a
- *      registration for the target instance, use that target-issued `(iss, sub)`.
- */
-export declare function resolveCredential(opts: {
-    as?: string;
-    creds?: string;
-    defaultIdentity?: string;
-}, config: AstraleConfig, audience?: string, registrationKey?: string): Promise<string>;
-export declare function resolveKeyIdentityAuthOptions(identity: Identity, config: AstraleConfig, audience?: string, registrationKey?: string): KeyIdentityAuthOptions;
-export declare function classifyNoRefreshTokenError(requestedAudience: string, sourceAudience: string | undefined, error: IdpSessionNoRefreshTokenError): IdpSessionNoRefreshTokenError | IdpAudienceMismatchError;
-/** A refresh attempt failed for a reason that re-login will NOT fix. */
-export declare class IdpRefreshTransientError extends Error {
-    constructor(message: string);
-}
-/** The IdP refused to scope the session to the target's organization. */
-export declare class IdpOrgMembershipError extends Error {
-    constructor(message: string);
-}

package/dist/types/connection/call.d.ts

@@ -1,3 +0,0 @@
-import { type Call } from '@astrale-os/sdk/client';
-/** Convert the CLI's untrusted text/JSON boundary into the one public Call representation. */
-export declare function createPathCall(path: string, input: unknown): Call;

package/dist/types/connection/command.d.ts

@@ -1,27 +0,0 @@
-import type { ConnectionContext } from './session';
-import type { ConnectionOptions } from './target';
-export interface KernelCommandOpts extends ConnectionOptions {
-    readonly raw?: boolean;
-    readonly json?: boolean;
-    readonly format?: 'yaml' | 'json';
-    readonly debug?: boolean;
-}
-export interface OperationRecovery {
-    readonly operation: string;
-    readonly retry: string;
-}
-/**
- * Encapsulates the standard kernel command lifecycle:
- * spinner → connect → call → timing → output → error handling.
- *
- * Commands provide a `fn` that does the actual work and an optional
- * `format` callback for custom output. If `format` is omitted, the
- * result is passed to the standard `output()` function.
- */
-export declare function runKernelCommand<T>(input: {
-    readonly opts: KernelCommandOpts;
-    readonly label: string;
-    readonly recovery?: OperationRecovery;
-    readonly fn: (context: ConnectionContext) => Promise<T>;
-    readonly format?: (result: T, options: KernelCommandOpts, machine: boolean) => void | Promise<void>;
-}): Promise<void>;

package/dist/types/connection/credential.d.ts

@@ -1,14 +0,0 @@
-import type { Fetch } from '@astrale-os/sdk/client';
-import type { SessionAuth } from '@astrale-os/sdk/client/session';
-import { type IssuerId } from '@astrale-os/sdk/auth';
-import type { AstraleConfig } from '../lib/config';
-import type { ConnectionOptions, ConnectionTarget } from './target';
-export interface SourceCredentialResolver {
-    resolve(audience: IssuerId, signal: AbortSignal): Promise<string>;
-}
-/** Resolve source authority; an omitted Session delegation preserves exact current authority. */
-export declare function createConnectionCredential(expectedSourceIssuer: IssuerId, source: SourceCredentialResolver): SessionAuth;
-/** Bind CLI identity state and Core Auth delegation to one Session auth capability. */
-export declare function createCliCredential(target: ConnectionTarget, options: ConnectionOptions, config: AstraleConfig, fetch?: Fetch, timeoutMs?: number): SessionAuth | undefined;
-/** Reject contradictory explicit credential selections before identity or network access. */
-export declare function validateCredentialSelection(options: ConnectionOptions): void;

package/dist/types/connection/errors.d.ts

@@ -1 +0,0 @@
-export { formatKernelError, functionInputIssues, schemaUpgradeHint } from './failure';

package/dist/types/connection/exchange.d.ts

@@ -1,9 +0,0 @@
-import type { IssuerId } from '@astrale-os/sdk/auth';
-import type { Fetch } from '@astrale-os/sdk/client';
-import type { SourceCredentialResolver } from './credential';
-import type { ConnectionTarget } from './target';
-import { ExchangeCredentialCache } from '../state/exchange-credentials';
-/** Exchange exact authenticated User authority for a Domain bearer bound to this Kernel. */
-export declare function createExchangeCredentialResolver(target: ConnectionTarget & {
-    readonly domainIssuer: IssuerId;
-}, source: SourceCredentialResolver, fetch: Fetch, timeoutMs: number, cache?: ExchangeCredentialCache): SourceCredentialResolver;

package/dist/types/connection/failure/classify.d.ts

@@ -1,2 +0,0 @@
-import type { FailureDiagnostic } from './model';
-export declare function classifyFailure(error: unknown): FailureDiagnostic;

package/dist/types/connection/failure/index.d.ts

@@ -1,5 +0,0 @@
-import type { OperationRecovery } from '../command';
-export { functionInputIssues, schemaUpgradeHint } from '../reasons';
-export declare function formatKernelError(error: unknown, machine: boolean, urlArg?: string, debug?: boolean, options?: {
-    recovery?: OperationRecovery;
-}): Promise<void>;

package/dist/types/connection/failure/model.d.ts

@@ -1,25 +0,0 @@
-export type TransportDiagnosticContext = {
-    readonly kind: 'acquisition';
-    readonly resource: 'publication' | 'bundle';
-} | {
-    readonly kind: 'invocation';
-    readonly delivery: 'not-sent' | 'unknown';
-    readonly invocation?: unknown;
-};
-export type FailureDiagnostic = {
-    readonly kind: 'simple';
-    readonly code: string;
-    readonly message: string;
-    readonly hint?: string;
-} | {
-    readonly kind: 'response';
-    readonly code: number;
-    readonly message: string;
-    readonly reason?: unknown;
-} | {
-    readonly kind: 'transport';
-    readonly code: 'CONNECTION_ERROR' | 'DISCONNECTED' | 'TIMEOUT' | 'TRANSPORT_ERROR';
-    readonly message: string;
-    readonly phase: string;
-    readonly context: TransportDiagnosticContext;
-};

package/dist/types/connection/failure/render.d.ts

@@ -1,3 +0,0 @@
-import type { OperationRecovery } from '../command';
-import type { FailureDiagnostic } from './model';
-export declare function renderFailure(failure: FailureDiagnostic, machine: boolean, url: string, recovery: OperationRecovery | undefined): void;

package/dist/types/connection/index.d.ts

@@ -1,8 +0,0 @@
-export { createPathCall } from './call';
-export { runKernelCommand } from './command';
-export type { KernelCommandOpts, OperationRecovery } from './command';
-export { expandSelfInCall, expandSelfInPath, withSelfHint } from './self';
-export type { SelfExpansionMeta } from './self';
-export { withAdminClientSession, withClientSession, type ConnectionContext } from './session';
-export { registrationKeyForTarget } from './target';
-export type { AdminConnectionOptions, ConnectionOptions, ConnectionTarget } from './target';

package/dist/types/connection/reasons.d.ts

@@ -1,37 +0,0 @@
-export type FunctionInputIssue = Readonly<{
-    code: string;
-    path?: string;
-    message: string;
-}>;
-export type QueryInputRepair = Readonly<{
-    phase: 'decode' | 'input';
-    path: string;
-}> | Readonly<{
-    phase: 'plan';
-    issue: string;
-    path?: string;
-}> | Readonly<{
-    phase: 'limit';
-    limit: string;
-    maximum: number;
-    actual: number;
-    path?: string;
-}>;
-export type SchemaUpgradeDetails = {
-    readonly origin?: string;
-    readonly issue?: undefined;
-} | {
-    readonly origin: string;
-    readonly issue: 'issuer-changed';
-    readonly installedIssuer: string;
-    readonly replacementIssuer: string;
-};
-export declare function reasonCode(reason: unknown): string | undefined;
-/** Admit only bounded caller-safe Function input issues established by the Kernel. */
-export declare function functionInputIssues(reason: unknown): readonly FunctionInputIssue[];
-/** Admit only public Query-input repair variants; unknown details remain machine-only. */
-export declare function queryInputRepair(reason: unknown): QueryInputRepair | undefined;
-/** Decode bounded recovery guidance while preserving the admitted reason itself elsewhere. */
-export declare function schemaUpgradeDetails(reason: unknown): SchemaUpgradeDetails | undefined;
-export declare function schemaUpgradeHint(details: SchemaUpgradeDetails): string;
-export declare function schemaDataRemovalHint(reason: unknown): string | undefined;

package/dist/types/connection/self.d.ts

@@ -1,37 +0,0 @@
-import type { ConnectionContext } from './session';
-/** Metadata attached to errors after an authenticated caller-authored @self expansion. */
-export interface SelfExpansionMeta {
-    readonly original: string;
-    readonly expanded: string;
-    readonly selfId: string;
-    readonly slug?: string;
-}
-/**
- * Run `action`; if it throws NodeUnavailableError, retain the authenticated
- * expansion for precise diagnostics. The error is re-thrown either way.
- */
-export declare function withSelfHint<T>(action: () => Promise<T>, meta: SelfExpansionMeta | undefined): Promise<T>;
-type AuthenticatedSelf = {
-    readonly id?: unknown;
-    readonly slug?: string;
-};
-export type ResolveSelfIdDependencies = {
-    readonly whoami?: (context: ConnectionContext) => Promise<AuthenticatedSelf>;
-};
-/** Resolve @self only from the effective principal authenticated by the selected Kernel. */
-export declare function resolveSelfIdAuthenticated(context: ConnectionContext, dependencies?: ResolveSelfIdDependencies): Promise<{
-    readonly id: string;
-    readonly slug?: string;
-}>;
-/** Expand @self in path-like commands and return metadata for NotFound diagnostics. */
-export declare function expandSelfInPath(path: string, context: ConnectionContext): Promise<{
-    readonly path: string;
-    readonly meta?: SelfExpansionMeta;
-}>;
-/** Expand @self once across one Call path and its CLI-authored string parameters. */
-export declare function expandSelfInCall(path: string, parameters: Readonly<Record<string, unknown>>, context: ConnectionContext): Promise<{
-    readonly path: string;
-    readonly parameters: Readonly<Record<string, unknown>>;
-    readonly meta?: SelfExpansionMeta;
-}>;
-export {};

package/dist/types/connection/session.d.ts

@@ -1,31 +0,0 @@
-import type { AuthApi } from '@astrale-os/sdk/auth';
-import type { GraphApi } from '@astrale-os/sdk/client';
-import type { ClientSessionOptions, SessionAuth } from '@astrale-os/sdk/client/session';
-import { ClientSession } from '@astrale-os/sdk/client/session';
-import type { AstraleConfig } from '../lib/config';
-import type { AdminConnectionOptions, ConnectionOptions, ConnectionTarget } from './target';
-import { connectAdminInstances, type InstanceInfo } from '../admin/instance';
-export interface ConnectionContext {
-    readonly session: ClientSession;
-    readonly graph: GraphApi;
-    readonly auth: AuthApi;
-    readonly target: ConnectionTarget;
-    /** Local identity label selected for this session; absent for raw credentials or anonymous use. */
-    readonly identity?: string;
-}
-interface OwnedConnection {
-    readonly context: ConnectionContext;
-    close(): void;
-}
-export type ConnectionFactory = (target: ConnectionTarget, timeoutMs: number, options: ConnectionOptions, config: AstraleConfig) => OwnedConnection;
-/** Resolve one ordinary target, run a command action, then close terminally. */
-export declare function withClientSession<Value>(options: ConnectionOptions, action: (context: ConnectionContext) => Promise<Value>): Promise<Value>;
-/** Resolve the configured Admin Domain target under the same terminal lifecycle. */
-export declare function withAdminClientSession<Value>(options: AdminConnectionOptions, action: (context: ConnectionContext) => Promise<Value>): Promise<Value>;
-/** Owner-private seam used to prove validation order and cleanup without network I/O. */
-export declare function withResolvedClientSession<Value>(target: ConnectionTarget, options: ConnectionOptions, config: AstraleConfig, action: (context: ConnectionContext) => Promise<Value>, open?: ConnectionFactory): Promise<Value>;
-export declare function resolveTimeoutMs(raw: string | undefined): number;
-/** Owner-private construction seam proving that transport and source identity stay distinct. */
-export declare function createClientSessionOptions(target: ConnectionTarget, fetch: NonNullable<ClientSessionOptions['fetch']>, auth: SessionAuth | undefined, timeoutMs: number): ClientSessionOptions;
-export declare function lookupManagedInstance(slug: string, options: ConnectionOptions, openAdmin?: typeof withAdminClientSession, connect?: typeof connectAdminInstances): Promise<InstanceInfo>;
-export {};

package/dist/types/connection/target.d.ts

@@ -1,38 +0,0 @@
-import type { IssuerId } from '@astrale-os/sdk/auth';
-import type { InstanceInfo } from '../lib/admin-instance';
-import type { AdminTargetCommandOpts } from '../lib/admin-target';
-import type { AstraleConfig } from '../lib/config';
-import type { InstanceStore } from '../lib/instance';
-export interface ConnectionOptions {
-    readonly url?: string;
-    readonly instance?: string;
-    readonly timeout?: string;
-    readonly as?: string;
-    readonly creds?: string;
-    readonly anonymous?: boolean;
-    readonly ci?: boolean;
-}
-export interface AdminConnectionOptions extends ConnectionOptions {
-    readonly admin?: string;
-    readonly adminUrl?: string;
-    readonly domainIssuer?: string;
-}
-export interface ConnectionTarget {
-    readonly url: string;
-    readonly kernelIssuer: IssuerId;
-    readonly domainIssuer?: IssuerId;
-    readonly slug?: string;
-    readonly defaultIdentity?: string;
-    readonly caFile?: string;
-}
-export interface TargetDependencies {
-    readonly instances?: InstanceStore;
-    readonly managed?: (slug: string) => Promise<InstanceInfo>;
-}
-/** Stable local identity-registration key for the exact selected source Kernel. */
-export declare function registrationKeyForTarget(target: ConnectionTarget): string;
-/** Resolve the existing URL / instance / active precedence into one exact source Kernel. */
-export declare function resolveConnectionTarget(options: ConnectionOptions, config: AstraleConfig, dependencies?: TargetDependencies): Promise<ConnectionTarget>;
-/** Resolve the configured Admin Domain target without entering managed-instance discovery. */
-export declare function resolveAdminConnectionTarget(options: AdminConnectionOptions, config: AstraleConfig, instances?: InstanceStore): Promise<ConnectionTarget>;
-export declare function adminLookupOptions(options: AdminConnectionOptions): AdminTargetCommandOpts;

package/dist/types/errors.d.ts

@@ -1,23 +0,0 @@
-export declare class AstraleError extends Error {
-    code: string;
-    hint?: string;
-    constructor(code: string, message: string, hint?: string, options?: ErrorOptions);
-}
-export declare class AuthError extends AstraleError {
-    constructor(message: string, hint?: string);
-}
-export declare class IssuerUnreachableError extends AstraleError {
-    constructor(url: string, hint?: string);
-}
-export declare class ReservedSlugError extends AstraleError {
-    constructor(slug: string);
-}
-export declare class IdentifierCollisionError extends AstraleError {
-    constructor(identifier: string, existingEntity: string);
-}
-export declare class IdentityKeyMissingError extends AstraleError {
-    constructor(subject: string);
-}
-export declare class NotImplementedError extends AstraleError {
-    constructor(feature: string, hint?: string);
-}

package/dist/types/identity/registry.d.ts

@@ -1,25 +0,0 @@
-import { type Identity, type IdentityMode, type IdentityStore, type Registration } from '../state/index';
-export type { Identity, IdentityStore, Registration } from '../state/index';
-export declare function readIdentities(): Promise<IdentityStore>;
-export declare function createIdentity(name: string, options?: {
-    readonly subject?: string;
-    readonly mode?: IdentityMode;
-    readonly issuer?: string;
-    readonly kid?: string;
-}): Promise<Identity>;
-export declare function deleteIdentity(name: string): Promise<void>;
-export declare function setDefault(name: string): Promise<void>;
-export declare function getDefault(): Promise<Identity & {
-    readonly name: string;
-}>;
-export declare function getIdentity(name: string): Promise<Identity>;
-export declare function upsertIdpIdentity(name: string, options: {
-    readonly subject: string;
-    readonly idp: string;
-    readonly issuer: string;
-    readonly audience?: string;
-    readonly claims?: Readonly<Record<string, unknown>>;
-    readonly use?: boolean;
-}): Promise<Identity>;
-export declare function setRegistration(name: string, instanceSlug: string, registration: Registration): Promise<void>;
-export declare function setIdentityMode(name: string, mode: IdentityMode): Promise<void>;

package/dist/types/keys/algorithm.d.ts

@@ -1,6 +0,0 @@
-/**
- * Resolve the JOSE algorithm to use with this key. Prefers `privateJwk.alg`
- * when present, falls back to inferring from `crv`/`kty` so keys generated
- * by older CLIs that did not stamp `alg`. Throws when neither form resolves.
- */
-export declare function inferAlg(privateJwk: Record<string, unknown>, keyPath?: string): string;

package/dist/types/keys/credential.d.ts

@@ -1,21 +0,0 @@
-import { type JWK } from 'jose';
-type AuthOptions = {
-    readonly issuer?: string;
-    readonly subject?: string;
-    readonly kid?: string;
-};
-export type AuthBinding = {
-    readonly credential: string;
-    readonly publicKey: {
-        readonly jwk: JWK;
-    };
-};
-export declare function persistAuth(keysDir?: string, opts?: AuthOptions): Promise<AuthBinding>;
-export declare function loadAuth(keysDir?: string, opts?: AuthOptions): Promise<AuthBinding>;
-export declare function resolveAuth(keysDir?: string, opts?: AuthOptions): Promise<AuthBinding>;
-export declare function signAs(subject: string, keysDir?: string, opts?: {
-    readonly issuer?: string;
-    readonly audience?: string;
-    readonly subject?: string;
-}): Promise<string>;
-export {};

package/dist/types/keys/index.d.ts

@@ -1,4 +0,0 @@
-export { acceptKeypair, fileExists, generateEd25519Jwk, importKeypair, keypairPaths, listIdentityKeys, persistKeypair, readKeypair, removeKeypair, } from './pair';
-export { loadAuth, persistAuth, resolveAuth, signAs } from './credential';
-export type { Keypair, KeypairInput, KeypairPaths } from './pair';
-export type { AuthBinding } from './credential';

package/dist/types/keys/pair.d.ts

@@ -1,34 +0,0 @@
-import { type JWK } from 'jose';
-export type KeypairPaths = {
-    readonly privatePath: string;
-    readonly publicPath: string;
-};
-export interface Keypair {
-    readonly privateJwk: JWK;
-    readonly publicJwk: JWK;
-    readonly kid?: string;
-}
-export interface KeypairInput {
-    readonly privateJwk: unknown;
-    readonly publicJwk: unknown;
-}
-/** Preserve manager filenames and confine every subject file to the selected key directory. */
-export declare function keypairPaths(subject: string, keysDir?: string): KeypairPaths;
-export declare function acceptKeypair(input: KeypairInput): Promise<Keypair>;
-export declare function fileExists(path: string): Promise<boolean>;
-export declare function listIdentityKeys(keysDir?: string): Promise<string[]>;
-export declare function generateEd25519Jwk(kid: string): Promise<{
-    readonly privateJwk: JWK;
-    readonly publicJwk: JWK;
-}>;
-export declare function persistKeypair(subject: string, opts?: {
-    readonly keysDir?: string;
-    readonly kid?: string;
-}): Promise<{
-    readonly publicJwk: JWK;
-    readonly privateJwk: JWK;
-    readonly kid: string;
-}>;
-export declare function readKeypair(subject: string, keysDir?: string): Promise<Keypair>;
-export declare function importKeypair(subject: string, input: KeypairInput, keysDir?: string): Promise<Keypair>;
-export declare function removeKeypair(subject: string, keysDir?: string): Promise<void>;

package/dist/types/lib/admin-instance.d.ts

@@ -1,17 +0,0 @@
-import type { AdminConnectionOptions, ConnectionContext } from '../connection';
-export { AdminInstanceNotFoundError, findOwnedInstance, formatInstanceState, type InstanceInfo, type InstanceState, type OwnedInstanceInfo, } from '../admin/instance';
-/** Resolve the Admin target and read only the caller-visible Instance inventory. */
-export declare function listOwnedInstances(options: AdminConnectionOptions): Promise<import("./admin-instance").OwnedInstanceInfo[]>;
-/** Read caller-visible inventory together with the exact local identity used for the Admin call. */
-export declare function listOwnedInstancesWithIdentity(options: AdminConnectionOptions): Promise<Readonly<{
-    instances: import("./admin-instance").OwnedInstanceInfo[];
-    identity?: string | undefined;
-}>>;
-/** Reuse an already-open Admin session for a caller-visible Instance inventory. */
-export declare function listOwnedInstancesInContext(context: ConnectionContext): Promise<import("./admin-instance").OwnedInstanceInfo[]>;
-/** Request one managed Instance; Admin owns infrastructure placement. */
-export declare function createOwnedInstance(options: AdminConnectionOptions, slug: string): Promise<import("./admin-instance").InstanceInfo>;
-/** Refresh one exact caller-visible Instance through its V2 receiver Method. */
-export declare function statusOwnedInstance(options: AdminConnectionOptions, identifier: string): Promise<import("./admin-instance").InstanceInfo>;
-/** Delete one exact caller-visible Instance through its V2 receiver Method. */
-export declare function deleteOwnedInstance(options: AdminConnectionOptions, identifier: string): Promise<import("./admin-instance").InstanceInfo>;

package/dist/types/lib/admin-target.d.ts

@@ -1,78 +0,0 @@
-import { z } from 'zod';
-import type { AstraleConfig } from './config';
-import type { InstanceStore } from './instance';
-export declare const DEFAULT_ADMIN_TARGET_NAME = "admin";
-export declare function defaultAdminTargetForChannel(channel: string): {
-    readonly url: string;
-    readonly domainIssuer: string;
-};
-export declare const DEFAULT_ADMIN_TARGET_URL: string;
-export declare const DEFAULT_ADMIN_DOMAIN_ISSUER: string;
-export declare const DEFAULT_ADMIN_TARGET_CONFIG: {
-    name: string;
-    url: string;
-    kernelIssuer: string;
-    domainIssuer: string;
-};
-export declare const AdminTargetConfigSchema: z.ZodEffects<z.ZodObject<{
-    /** Friendly name / auth registration slug for direct URL admin targets. */
-    name: z.ZodOptional<z.ZodString>;
-    /** Direct admin kernel URL. */
-    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    /** Kernel issuer / JWT audience when different from url. */
-    kernelIssuer: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    /** Exact native Admin Domain issuer used by the standard token exchange. */
-    domainIssuer: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
-    /** Bookmark name for the admin kernel. */
-    instance: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    name?: string | undefined;
-    url?: string | undefined;
-    kernelIssuer?: string | undefined;
-    domainIssuer?: string | undefined;
-    instance?: string | undefined;
-}, {
-    name?: string | undefined;
-    url?: string | undefined;
-    kernelIssuer?: string | undefined;
-    domainIssuer?: string | undefined;
-    instance?: string | undefined;
-}>, {
-    name?: string | undefined;
-    url?: string | undefined;
-    kernelIssuer?: string | undefined;
-    domainIssuer?: string | undefined;
-    instance?: string | undefined;
-}, {
-    name?: string | undefined;
-    url?: string | undefined;
-    kernelIssuer?: string | undefined;
-    domainIssuer?: string | undefined;
-    instance?: string | undefined;
-}>;
-export type AdminTargetConfig = z.infer<typeof AdminTargetConfigSchema>;
-export type AdminTargetCommandOpts = {
-    admin?: string;
-    adminUrl?: string;
-    domainIssuer?: string;
-    instance?: string;
-    url?: string;
-};
-export type AdminTargetSource = 'admin-url' | 'admin' | 'config-instance' | 'config-url' | 'default';
-export type ResolvedAdminTarget = {
-    name: string;
-    url: string;
-    kernelIssuer: string;
-    domainIssuer: string;
-    defaultIdentity?: string;
-    caFile?: string;
-    source: AdminTargetSource;
-    configured: boolean;
-    registrationSlug: string;
-};
-export declare const ADMIN_TARGET_OPTIONS: {
-    flags: string;
-    description: string;
-}[];
-export declare function resolveAdminTarget(opts: AdminTargetCommandOpts, config: AstraleConfig, store?: InstanceStore): Promise<ResolvedAdminTarget>;
-export declare function resolveAdminTargetFromStore(opts: AdminTargetCommandOpts, config: AstraleConfig, store: InstanceStore): ResolvedAdminTarget;

package/dist/types/lib/ca-fetch.d.ts

@@ -1,2 +0,0 @@
-/** Create a Fetch capability whose HTTPS requests trust one CLI-selected CA file. */
-export declare function fetchWithCaFile(caFile: string, fallback?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;