@kivel.io/sdk 0.0.0-stage → 0.6.1

package/dist/index.d.ts

@@ -0,0 +1,358 @@
+export * from './types.js';
+import type { Authenticator, AuthenticatorInput, TotpCode, EmailAttachmentLink, OAuthProviderInput, OAuthProvider, CreatedOAuthProvider, AgentLogin, AgentToken, AgentTrial, Approval, ApprovalInput, EmailInbox, EmailMessage, EmailContent, EmailThread, EmailThreadsPage, EmailDraft, EmailRules, MemoryEntry, Monitor, MonitorInput, WaitOptions } from './types.js';
+export interface ClientOptions {
+    baseUrl?: string | undefined;
+    apiKey?: string | undefined;
+    fetch?: typeof fetch | undefined;
+    timeoutMs?: number | undefined;
+}
+export interface ResourceSettings {
+    ttlSeconds?: number | undefined;
+    persistent?: boolean | undefined;
+    visibility?: 'public' | 'private' | undefined;
+}
+export interface UploadSettings extends ResourceSettings {
+    maxDownloads?: number | undefined;
+}
+export interface ResourceCredentials {
+    visibility: 'public' | 'private';
+    accessVersion: string;
+    accessToken?: string;
+    id: string;
+    expiresAt: string;
+    managementToken?: string;
+    inspectionToken?: string;
+}
+export interface CapturedRequest {
+    id: string;
+    method: string;
+    path: string;
+    rawQuery?: string;
+    headers: Record<string, string | string[]>;
+    query: Record<string, string | string[]>;
+    body: string;
+    bodyEncoding: 'utf8' | 'base64';
+    bodySize: number;
+    timestamp: string;
+}
+export interface InboxResponse {
+    status?: number;
+    contentType?: 'application/json' | 'text/plain' | 'application/xml' | 'text/xml';
+    body?: string;
+    headers?: Record<string, string>;
+    delayMs?: number;
+}
+export interface Execution {
+    toolId: string;
+    output: string;
+    usage: {
+        used: number;
+        limit: number;
+        resetsAt: string;
+    };
+}
+export declare class KivelError extends Error {
+    readonly status: number;
+    readonly requestId?: string | undefined;
+    readonly retryAfter?: number | undefined;
+    readonly requiredPlan?: string | undefined;
+    readonly upgradeUrl?: string | undefined;
+    constructor(message: string, status: number, requestId?: string | undefined, retryAfter?: number | undefined, requiredPlan?: string | undefined, upgradeUrl?: string | undefined);
+}
+export declare class Kivel {
+    private options;
+    readonly baseUrl: string;
+    private fetcher;
+    private timeoutMs;
+    constructor(options?: ClientOptions);
+    request<T = unknown>(method: string, path: string, body?: unknown, resourceToken?: string, headers?: Record<string, string>): Promise<T>;
+    tools(): Promise<{
+        tools: {
+            id: string;
+            name: string;
+            status: 'available' | 'coming-soon';
+            minimumPlan?: 'free' | 'pro' | 'team' | null;
+            execution: string | null;
+            description?: string;
+            guide?: {
+                action: string;
+                acceptsText: boolean;
+                acceptsFile: boolean;
+                inputLabel?: string;
+                inputExample?: string;
+                options: {
+                    key: string;
+                    label: string;
+                    defaultValue: string;
+                    choices?: [string, string][];
+                    min?: number;
+                    max?: number;
+                }[];
+                description?: string;
+                limits?: string;
+                steps?: string[];
+                example?: string;
+            };
+        }[];
+    }>;
+    tool(id: string): Promise<Record<string, unknown>>;
+    run(toolId: string, input?: string, options?: Record<string, string>, file?: {
+        name: string;
+        base64: string;
+    } | {
+        name: string;
+        base64: string;
+    }[]): Promise<Execution>;
+    plans(): Promise<unknown>;
+    activity(): Promise<unknown>;
+    startLogin(name: string, client?: string): Promise<AgentLogin>;
+    finishLogin(deviceCode: string): Promise<AgentToken>;
+    startTrial(name: string, humanEmail?: string, client?: string): Promise<AgentTrial>;
+    agents(): Promise<unknown>;
+    /** Only for accounts your human asked you to create or operate. */
+    addAuthenticator(input: AuthenticatorInput): Promise<Authenticator>;
+    listAuthenticators(): Promise<{
+        authenticators: Authenticator[];
+        limit: number;
+    }>;
+    getTotpCode(id: string): Promise<TotpCode>;
+    renameAuthenticator(id: string, name: string): Promise<{
+        id: string;
+        name: string;
+    }>;
+    deleteAuthenticator(id: string): Promise<void>;
+    getEmailAttachment(id: string, messageId: string, attachmentId: string): Promise<EmailAttachmentLink>;
+    downloadEmailAttachment(id: string, messageId: string, attachmentId: string): Promise<Uint8Array>;
+    createEmailInbox(settings?: import('./types.js').EmailInboxSettings): Promise<EmailInbox>;
+    emailInboxes(): Promise<{
+        inboxes: EmailInbox[];
+    }>;
+    clearEmails(id: string, token?: string): Promise<void>;
+    sendEmail(id: string, input: import('./types.js').SendEmailInput): Promise<{
+        id: string;
+        status: 'sent';
+        providerIds: string[];
+    }>;
+    emailThreads(id?: string, settings?: {
+        cursor?: string | undefined;
+        limit?: number | undefined;
+    }): Promise<EmailThreadsPage>;
+    emailThread(id: string, threadId: string): Promise<EmailThread>;
+    createEmailDraft(id: string, content: EmailContent): Promise<EmailDraft & {
+        content: EmailContent;
+    }>;
+    emailDrafts(id: string): Promise<{
+        drafts: EmailDraft[];
+    }>;
+    emailDraft(id: string): Promise<EmailDraft & {
+        content: EmailContent;
+    }>;
+    submitEmailDraft(id: string, settings?: {
+        approval?: boolean;
+        sendAt?: string;
+    }): Promise<EmailDraft & {
+        content: EmailContent;
+    }>;
+    deleteEmailDraft(id: string): Promise<void>;
+    emailInboxRules(id: string): Promise<{
+        rules: EmailRules;
+    }>;
+    waitForEvent(sources: import('./types.js').SocketEventSource[], timeoutSeconds?: number): Promise<{
+        timedOut: boolean;
+        events: import('./types.js').SocketEvent[];
+    }>;
+    emailForwarding(id: string, url: string | null, token?: string): Promise<{
+        forwardingUrl: string | null;
+    }>;
+    emailInbox(id: string, token?: string): Promise<EmailInbox>;
+    emails(id: string, token?: string): Promise<{
+        messages: EmailMessage[];
+    }>;
+    waitForEmail(id: string, options?: WaitOptions): Promise<{
+        timedOut: boolean;
+        messages: EmailMessage[];
+    }>;
+    memorySet<T>(namespace: string, key: string, value: T, ttlSeconds?: number): Promise<Omit<MemoryEntry<T>, "value">>;
+    memoryGet<T = unknown>(namespace: string, key: string): Promise<MemoryEntry<T>>;
+    memoryList(namespace: string, prefix?: string): Promise<{
+        keys: Omit<MemoryEntry, 'value'>[];
+        usedBytes: number;
+        limitBytes: number;
+    }>;
+    memoryDelete(namespace: string, key: string): Promise<void>;
+    availablePhoneNumbers(areaCode?: string): Promise<{
+        numbers: {
+            number: string;
+            monthlyCost: string;
+            upfrontCost: string;
+            currency: string;
+        }[];
+    }>;
+    createPhoneNumber(number: string, idempotencyKey: string): Promise<{
+        number: Record<string, unknown>;
+    }>;
+    listPhoneNumbers(): Promise<{
+        enabled: boolean;
+        numbers: Record<string, unknown>[];
+    }>;
+    releasePhoneNumber(id: string): Promise<void>;
+    listSms(id: string): Promise<{
+        messages: Record<string, unknown>[];
+    }>;
+    waitForSms(id: string, options?: {
+        after?: string;
+        timeoutSeconds?: number;
+    }): Promise<{
+        timedOut: boolean;
+        messages: Record<string, unknown>[];
+    }>;
+    createSmtpInbox(settings?: ResourceSettings): Promise<{
+        id: string;
+        expiresAt: string;
+        smtp: {
+            host: string;
+            port: number;
+            secure: boolean;
+            username: string;
+            password: string;
+        };
+    }>;
+    smtpInbox(id: string): Promise<{
+        id: string;
+        expiresAt: string;
+        smtp: {
+            host: string;
+            port: number;
+            secure: boolean;
+            username: string;
+        };
+        enabled: boolean;
+    }>;
+    rotateSmtpPassword(id: string): Promise<{
+        smtp: {
+            host: string;
+            port: number;
+            secure: boolean;
+            username: string;
+            password: string;
+        };
+    }>;
+    createScheduledJob(config: {
+        name: string;
+        url: string;
+        body?: unknown;
+        delaySeconds?: number;
+        startAt?: string;
+        intervalSeconds?: number;
+        maxRuns?: number;
+    }, settings?: ResourceSettings): Promise<{
+        id: string;
+        status: string;
+        nextRunAt: string;
+    }>;
+    scheduledJobs(): Promise<{
+        jobs: Record<string, unknown>[];
+    }>;
+    scheduledJob(id: string): Promise<Record<string, unknown>>;
+    cancelScheduledJob(id: string): Promise<void>;
+    createStatusPage(config: {
+        name: string;
+        description?: string;
+        monitorIds: string[];
+    }, settings?: ResourceSettings): Promise<{
+        id: string;
+        pageUrl: string;
+        expiresAt: string;
+        accessToken?: string;
+    }>;
+    updateStatusPage(id: string, config: {
+        name: string;
+        description?: string;
+        monitorIds: string[];
+    }): Promise<unknown>;
+    acceptDnsChanges(id: string): Promise<{
+        accepted: boolean;
+    }>;
+    createMonitor(settings: MonitorInput): Promise<Monitor>;
+    monitors(): Promise<{
+        monitors: Monitor[];
+        limit: number;
+        minIntervalSeconds: number;
+    }>;
+    monitor(id: string): Promise<Monitor>;
+    pingMonitor(token: string, failed?: boolean): Promise<{
+        ok: true;
+        status: 'up' | 'down';
+    }>;
+    pauseMonitor(id: string, paused?: boolean): Promise<{
+        paused: boolean;
+    }>;
+    deleteMonitor(id: string): Promise<void>;
+    askHuman(input: ApprovalInput): Promise<Approval>;
+    approvals(pendingOnly?: boolean): Promise<{
+        approvals: Approval[];
+    }>;
+    approval(id: string): Promise<Approval>;
+    waitForApproval(id: string, timeoutSeconds?: number): Promise<Approval & {
+        timedOut: boolean;
+    }>;
+    inspectResource(kind: 'inboxes' | 'mocks' | 'files' | 'mcp-servers' | 'email-inboxes' | 'status-pages', id: string, token?: string): Promise<unknown>;
+    updateMock(id: string, config: unknown, token?: string): Promise<unknown>;
+    resetMock(id: string, token?: string): Promise<unknown>;
+    mockCalls(id: string, token?: string): Promise<unknown>;
+    setInboxForward(id: string, url: string | null, token?: string): Promise<unknown>;
+    inboxDeliveries(id: string, token?: string): Promise<unknown>;
+    private waitTimeout;
+    private waitQuery;
+    usage(): Promise<unknown>;
+    resources(): Promise<unknown>;
+    /** Senders can POST to webhookUrl without credentials by default. Inspection stays private.
+     * Set visibility to private to require X-Access-Token on incoming webhooks. */
+    createInbox(settings?: ResourceSettings): Promise<ResourceCredentials & {
+        webhookUrl: string;
+    }>;
+    inspectInbox(id: string, token?: string): Promise<unknown>;
+    /**
+     * Long-polls until the inbox captures a request newer than `after` (any request when omitted).
+     * Resolves with `timedOut: true` when nothing arrives; call again to keep waiting.
+     */
+    waitForRequests(id: string, options?: {
+        token?: string;
+        after?: string;
+        timeoutSeconds?: number;
+    }): Promise<{
+        timedOut: boolean;
+        requests: CapturedRequest[];
+    }>;
+    setInboxResponse(id: string, response: InboxResponse | null, token?: string): Promise<unknown>;
+    createOAuthProvider(config: OAuthProviderInput, settings?: Omit<ResourceSettings, 'visibility'>): Promise<CreatedOAuthProvider>;
+    oauthProvider(id: string): Promise<OAuthProvider>;
+    oauthProviders(): Promise<{
+        providers: OAuthProvider[];
+    }>;
+    updateOAuthProvider(id: string, config: OAuthProviderInput): Promise<void>;
+    deleteOAuthProvider(id: string): Promise<void>;
+    createMock(config: unknown, settings?: ResourceSettings): Promise<ResourceCredentials & {
+        endpointUrl: string;
+    }>;
+    createMcpServer(config: unknown, settings?: ResourceSettings): Promise<ResourceCredentials & {
+        endpointUrl: string;
+    }>;
+    upload(name: string, data: Uint8Array, settings?: UploadSettings): Promise<ResourceCredentials & {
+        downloadUrl: string;
+    }>;
+    sharing(kind: 'inboxes' | 'mocks' | 'files' | 'mcp-servers' | 'status-pages', id: string, visibility: 'public' | 'private', token?: string): Promise<{
+        visibility: 'public' | 'private';
+        accessVersion: string;
+        accessToken?: string;
+    }>;
+    downloadFile(id: string, accessToken?: string): Promise<Uint8Array>;
+    remove(kind: 'inboxes' | 'mocks' | 'files' | 'mcp-servers' | 'email-inboxes' | 'status-pages', id: string, token?: string): Promise<void>;
+    renew(kind: 'inboxes' | 'mocks' | 'files' | 'mcp-servers' | 'email-inboxes' | 'status-pages', id: string, settings?: {
+        persistent?: boolean;
+    }, token?: string): Promise<{
+        id: string;
+        expiresAt: string;
+        persistent: boolean;
+    }>;
+}