type EmberJson = null | boolean | number | string | EmberJson[] | { [key: string]: EmberJson };

interface EmberAppletMetadata {
  readonly id: string;
  readonly name: string;
  readonly version: string;
  readonly manifestVersion: 1 | 2;
  readonly permissions: readonly string[];
  readonly capabilities: readonly string[];
}

interface EmberStorage {
  get(key: string): Promise<EmberJson | null>;
  set(key: string, value: EmberJson): Promise<void>;
  delete(key: string): Promise<void>;
  keys(): Promise<string[]>;
  clear(): Promise<void>;
}

interface EmberSettings { get(): Promise<Record<string, EmberJson>>; }

type EmberHttpBody =
  | { type: "text"; value: string }
  | { type: "json"; value: EmberJson }
  | { type: "base64"; value: string }
  | { type: "form"; value: Record<string, string> };

interface EmberHttpRequest {
  /** The applet-supplied URL. Ember adds protected query credentials to an internal copy. */
  url: string;
  method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
  headers?: Record<string, string>;
  body?: EmberHttpBody;
  timeoutMs?: number;
  responseType?: "json" | "text" | "bytes";
  maxResponseBytes?: number;
  profile?: string;
  /** Credential slot names to attach. Manifest placement decides header, form, or query insertion. */
  credentials?: string[];
}

interface EmberHttpResponse {
  status: number;
  statusText: string;
  headers: Record<string, string>;
  body: EmberJson;
}

interface EmberHttp { request(request: EmberHttpRequest): Promise<EmberHttpResponse>; }

interface EmberSecrets {
  prompt(name: string): Promise<void>;
  has(name: string): Promise<boolean>;
  delete(name: string): Promise<void>;
}

interface EmberBackend {
  invoke<T extends EmberJson = EmberJson>(method: string, payload?: EmberJson): Promise<T>;
  subscribe<T extends EmberJson = EmberJson>(event: string, listener: (payload: T) => void): () => void;
}

interface EmberOAuthRequest {
  authorizationUrl: string;
  tokenUrl: string;
  clientId: string;
  scopes: string[];
  credentialName: string;
  extraAuthorizationParameters?: Record<string, string>;
}

interface EmberAuth {
  authorize(request: EmberOAuthRequest): Promise<{ credentialName: string }>;
}

interface EmberExternal { openUrl(url: string): Promise<void>; }

interface EmberWindow {
  setFullscreen(fullscreen: boolean): Promise<void>;
  isFullscreen(): Promise<boolean>;
}

interface EmberTerminal {
  open(options?: { cols?: number; rows?: number }): Promise<{ id: string; cols: number; rows: number }>;
  write(id: string, data: string): Promise<void>;
  resize(id: string, cols: number, rows: number): Promise<void>;
  subscribe(id: string, listener: (data: string) => void): () => void;
  close(id: string): Promise<void>;
}

type EmberExtensionMethod = (payload?: EmberJson) => Promise<EmberJson>;
type EmberExtensionApi = { readonly [name: string]: EmberExtensionApi | EmberExtensionMethod };

declare class EmberApiError extends Error { readonly code: string; }

interface EmberApi {
  readonly applet: EmberAppletMetadata;
  readonly storage: EmberStorage;
  readonly settings: EmberSettings;
  readonly http: EmberHttp;
  readonly secrets: EmberSecrets;
  readonly backend: EmberBackend;
  readonly auth: EmberAuth;
  readonly external: EmberExternal;
  readonly window: EmberWindow;
  /** An in-memory guest shell. It has no host filesystem, process, or network access. */
  readonly terminal: EmberTerminal;
  /** Trusted native extension APIs requested by this applet's signed manifest. */
  readonly extension: EmberExtensionApi;
  readonly EmberApiError: typeof EmberApiError;
}

declare const ember: EmberApi;
interface Window { readonly ember: EmberApi; }