import * as v from "@badrap/valita";
import { HTTPError, APIError, type ClientConfig } from "./client.ts";
import { Kv } from "./kv.ts";
import type * as KvTypes from "./kv.ts";
export { HTTPError, APIError };
export declare class UpdateFailed extends Error {
    constructor(cause: APIError);
}
type InstallationStatus = "active" | "paused" | "uninstalled";
declare const InstallationStatus: v.Type<InstallationStatus>;
type InstallationOwner = {
    type: "team";
    name: string;
} | {
    type: "user";
    email: string;
};
declare const InstallationOwner: v.Type<InstallationOwner>;
export type Installation<State extends Record<string, unknown>> = {
    id: string;
    state: State;
    owner?: InstallationOwner;
    status: InstallationStatus;
};
export type Asset = Readonly<{
    type: "ip" | "email" | "domain" | "opaque";
    value: string;
    key?: string;
    props?: Record<string, unknown>;
}>;
export type Event = Readonly<{
    type: "ip" | "email" | "domain" | "opaque";
    value: string;
    key?: string;
    props?: Record<string, unknown>;
}>;
type MaybePromise<T> = Promise<T> | T;
interface Config<InstallationState> extends ClientConfig {
    stateType?: v.Type<InstallationState>;
}
export declare class API<InstallationState extends Record<string, unknown> = Record<string, unknown>> {
    #private;
    readonly kv: Kv;
    constructor(config: Config<InstallationState>);
    checkAuthToken(token: string): Promise<{
        installationId: string;
        sessionId: string;
        expiresAt: number;
    }>;
    listInstallations(options?: {
        status?: InstallationStatus | InstallationStatus[];
    }): AsyncIterable<{
        id: string;
        owner?: {
            type: "team";
            name: string;
        } | {
            type: "user";
            email: string;
        };
        status: InstallationStatus;
    }>;
    createInstallationCallback(installationId: string, sessionId: string, callback?: {
        action?: unknown;
        clientState?: Record<string, unknown>;
    }): Promise<string>;
    getInstallation(installationId: string): Promise<Installation<InstallationState>>;
    updateInstallation(installationId: string, callback: (installation: Installation<InstallationState>) => MaybePromise<{
        assets?: Asset[];
        state?: InstallationState;
    } | undefined>, options?: {
        retry?: false | number;
    }): Promise<Installation<InstallationState>>;
    removeInstallation(installationId: string): Promise<void>;
    listOwnerAssets(installationId: string): AsyncIterable<{
        type: "ip" | "email" | "domain";
        value: string;
    }>;
    ensureFeed(name: string, config?: {
        title?: string;
        summaryTemplate?: unknown;
        detailsTemplate?: unknown;
    }): Promise<void>;
    feedEventsForInstallation(installationId: string, feedName: string, events: Event[]): Promise<void>;
}
export declare namespace API {
    type Kv = KvTypes.Kv;
    type KvKey = KvTypes.KvKey;
    type KvEntry<T = unknown> = KvTypes.KvEntry<T>;
    type KvEntryMaybe<T = unknown> = KvTypes.KvEntryMaybe<T>;
    type KvCheck = KvTypes.KvCheck;
    type KvMutation = KvTypes.KvMutation;
    type KvCommitResult = KvTypes.KvCommitResult;
    type KvCommitError = KvTypes.KvCommitError;
    type KvListSelector = KvTypes.KvListSelector;
    type KvListOptions = KvTypes.KvListOptions;
    type KvListIterator<T = unknown> = KvTypes.KvListIterator<T>;
    type KvAtomicOperation = KvTypes.KvAtomicOperation;
}