@isomorph.ai/app-sdk 1.2.1

package/dist/index.d.ts

@@ -0,0 +1,367 @@
+export type IsomorphErrorCategory = 'AUTH_REQUIRED' | 'FORBIDDEN' | 'NOT_FOUND' | 'CONFLICT' | 'VALIDATION_FAILED' | 'RATE_LIMITED' | 'UNAVAILABLE' | 'INTERNAL';
+export declare class IsomorphError extends Error {
+    readonly category: IsomorphErrorCategory;
+    readonly requestId?: string | undefined;
+    readonly details?: unknown | undefined;
+    /** The HTTP status the gateway answered, when the error came from a response. */
+    readonly status?: number | undefined;
+    constructor(category: IsomorphErrorCategory, message: string, requestId?: string | undefined, details?: unknown | undefined, 
+    /** The HTTP status the gateway answered, when the error came from a response. */
+    status?: number | undefined);
+}
+export interface IsomorphUser {
+    id: string;
+    email: string;
+    appUser?: unknown;
+}
+export interface IsomorphResult<T> {
+    data: T;
+    count?: number;
+}
+export interface SlackChannelHistoryRequest {
+    operation: 'slack.channel.history';
+    resource: string;
+    input?: {
+        /** How many newest messages to read: an integer from 1 to 15 (the platform's ceiling); default 15. */
+        limit?: number;
+    };
+}
+export interface SlackMessagePostRequest {
+    operation: 'slack.message.post';
+    resource: string;
+    input: {
+        /** Plain text, 1 to 4000 characters. Posted as the app (under the IT-approved per-app name) or as the signed-in person (their consent), the same text either way. */
+        text: string;
+    };
+    /** A fresh UUID per explicit Send press, reused only to retry that press. */
+    idempotencyKey: string;
+    /**
+     * Which of the modes IT approved for this app the post runs under: `app` (the company's Slack app, under the
+     * IT-approved per-app name and footer) or `user` (the signed-in person, after their consent). Leave it out when
+     * the app is approved for one mode; an app approved for both must say (MODE_REQUIRED), and a mode IT has not
+     * approved is refused with MODE_NOT_GRANTED — never served under the other mode.
+     */
+    mode?: 'app' | 'user';
+}
+export interface WarehouseViewReadRequest {
+    operation: 'warehouse.view.read';
+    resource: string;
+    input: {
+        /** 1 to 32 approved column names, or `['*']` when IT exposes all current and future columns. */
+        columns: string[];
+        /** How many rows to read: an integer from 1 to 1000; default 100. */
+        limit?: number;
+    };
+}
+/** Gmail runs as the signed-in person after their consent. Resources are approved mailbox aliases. */
+export interface GmailThreadListRequest {
+    operation: 'gmail.thread.list';
+    resource: string;
+    input?: {
+        limit?: number;
+    };
+}
+export interface GmailMessageReadRequest {
+    operation: 'gmail.message.read';
+    resource: string;
+    input: {
+        messageId: string;
+    };
+}
+export interface GmailMessageSendRequest {
+    operation: 'gmail.message.send';
+    resource: string;
+    input: {
+        /** 1 to 50 email addresses per recipient list. */
+        to: string[];
+        cc?: string[];
+        bcc?: string[];
+        /** 1 to 256 characters. */
+        subject: string;
+        /** Plain text, 1 to 4000 characters. Attachments and HTML are not supported. */
+        text: string;
+        replyToMessageId?: string;
+    };
+    /** A fresh UUID per authorized Send action, reused only to retry that action. */
+    idempotencyKey: string;
+}
+export type IntegrationRequest = SlackChannelHistoryRequest | SlackMessagePostRequest | WarehouseViewReadRequest | GmailThreadListRequest | GmailMessageReadRequest | GmailMessageSendRequest;
+export type IntegrationOperation = IntegrationRequest['operation'];
+export interface SlackMessage {
+    id: string;
+    text: string;
+    authorId: string;
+    createdAt: string;
+    /** The per-app display name a post under a per-app name carries (an app can recognise its own posts); absent on a person's message and on a post under the bot's own name. */
+    authorName?: string;
+    /** The emoji shortcode such a post carries as its icon, e.g. `:green_salad:`, when it has one. */
+    authorIcon?: string;
+}
+export interface SlackChannelHistoryResult {
+    messages: SlackMessage[];
+    hasMore: boolean;
+}
+export interface SlackMessagePostResult {
+    messageId: string;
+}
+export interface WarehouseViewReadResult {
+    rows: Array<Record<string, unknown>>;
+}
+export interface GmailThreadSummary {
+    id: string;
+    messageId: string;
+    subject: string;
+    from: string;
+    date: string;
+    snippet: string;
+}
+export interface GmailThreadListResult {
+    threads: GmailThreadSummary[];
+    hasMore: boolean;
+}
+export interface GmailMessageReadResult {
+    id: string;
+    threadId: string;
+    subject: string;
+    from: string;
+    to: string;
+    date: string;
+    text: string;
+    truncated: boolean;
+}
+export interface GmailMessageSendResult {
+    messageId: string;
+    threadId: string;
+}
+export type IntegrationResult<R extends IntegrationRequest> = R extends SlackChannelHistoryRequest ? SlackChannelHistoryResult : R extends SlackMessagePostRequest ? SlackMessagePostResult : R extends WarehouseViewReadRequest ? WarehouseViewReadResult : R extends GmailThreadListRequest ? GmailThreadListResult : R extends GmailMessageReadRequest ? GmailMessageReadResult : R extends GmailMessageSendRequest ? GmailMessageSendResult : never;
+export type IntegrationConnectResult = {
+    status: 'connected';
+    accountLabel: string;
+} | {
+    status: 'consent_required';
+    authorizationUrl: string;
+};
+export interface IntegrationDisconnectResult {
+    status: 'disconnected';
+}
+export type AiRole = 'system' | 'user' | 'assistant';
+export interface AiMessage {
+    role: AiRole;
+    content: string;
+}
+export interface AiChatRequest {
+    messages: AiMessage[];
+    /** A governed model alias; omitted means the tenant's default generation route. */
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+export interface AiChatResult {
+    /** The assistant reply, plain text. */
+    content: string;
+    /** The governed model alias that answered. */
+    model: string;
+    finishReason: 'stop' | 'length' | 'content_filter' | 'other';
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    /** The AI gateway trace id, for IT's activity view. */
+    traceId?: string;
+}
+export interface AiEmbedRequest {
+    input: string | string[];
+    model?: string;
+}
+export interface AiEmbedResult {
+    embeddings: number[][];
+    model: string;
+    usage: {
+        inputTokens: number;
+    };
+    traceId?: string;
+}
+/** Stable reason codes governed AI answers with in IsomorphError.details.code. */
+export type AiErrorCode = 'AI_NOT_ENABLED' | 'AI_POLICY_DENIED' | 'AI_QUOTA_EXCEEDED' | 'AI_PROVIDER_ERROR' | 'AI_UNAVAILABLE' | 'REQUEST_TOO_LARGE' | 'VALIDATION_FAILED';
+/** The AI reason code carried by an error, when it is a governed-AI refusal. */
+export declare function aiErrorCode(error: unknown): AiErrorCode | undefined;
+type Fetch = typeof globalThis.fetch;
+type SocketFactory = (url: string) => WebSocket;
+export interface ClientOptions {
+    baseUrl?: string;
+    fetch?: Fetch;
+    websocket?: SocketFactory;
+    /**
+     * Under the kit gate's runner (never in a browser): which of the two signed
+     * identities the runner minted this client acts as. The default is the
+     * first person; 'second-user' is the second, for a check that proves one
+     * person cannot reach another's rows. The runner supplies both; a check
+     * never reads a token name itself.
+     */
+    identity?: 'second-user';
+    realtimeReconnectMs?: number;
+    identityRefreshMs?: number;
+    setTimeout?: typeof globalThis.setTimeout;
+    clearTimeout?: typeof globalThis.clearTimeout;
+}
+interface Filter {
+    column: string;
+    operator: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'is' | 'not' | 'in' | 'ilike' | 'or';
+    value: unknown;
+    secondaryOperator?: string;
+}
+interface Query {
+    operation: 'select' | 'insert' | 'update' | 'upsert' | 'delete';
+    columns?: string;
+    values?: unknown;
+    filters: Filter[];
+    orders: Array<{
+        column: string;
+        ascending: boolean;
+        nullsFirst?: boolean;
+    }>;
+    limit?: number;
+    range?: {
+        from: number;
+        to: number;
+    };
+    cardinality?: 'single' | 'maybeSingle';
+    count?: 'exact';
+    head?: boolean;
+    onConflict?: string[];
+}
+interface IdentityRenewal {
+    renewals(): number;
+    renew(sentAt: number): Promise<void>;
+}
+declare class Transport {
+    private readonly onUnauthorized?;
+    readonly baseUrl: string;
+    readonly fetch: Fetch;
+    private readonly identity;
+    renewal: IdentityRenewal | undefined;
+    constructor(options: ClientOptions, onUnauthorized?: (() => void) | undefined);
+    json<T>(path: string, init?: RequestInit): Promise<T>;
+    private request;
+}
+export declare class QueryBuilder<T = Record<string, unknown>, Result = T[]> implements PromiseLike<IsomorphResult<Result>> {
+    private readonly transport;
+    private readonly table;
+    private readonly query;
+    constructor(transport: Transport, table: string, query?: Query);
+    private next;
+    select(columns?: string, options?: {
+        count?: 'exact';
+        head?: boolean;
+    }): QueryBuilder<T, Result>;
+    insert(values: unknown): QueryBuilder<T, Result>;
+    update(values: unknown): QueryBuilder<T, Result>;
+    upsert(values: unknown, options?: {
+        onConflict?: string | string[];
+    }): QueryBuilder<T, Result>;
+    delete(): QueryBuilder<T, Result>;
+    eq(column: string, value: unknown): QueryBuilder<T, Result>;
+    neq(column: string, value: unknown): QueryBuilder<T, Result>;
+    gt(column: string, value: unknown): QueryBuilder<T, Result>;
+    gte(column: string, value: unknown): QueryBuilder<T, Result>;
+    lt(column: string, value: unknown): QueryBuilder<T, Result>;
+    lte(column: string, value: unknown): QueryBuilder<T, Result>;
+    is(column: string, value: unknown): QueryBuilder<T, Result>;
+    in(column: string, values: unknown[]): QueryBuilder<T, Result>;
+    ilike(column: string, value: string): QueryBuilder<T, Result>;
+    or(expression: string): QueryBuilder<T, Result>;
+    not(column: string, operator: string, value: unknown): QueryBuilder<T, Result>;
+    private filter;
+    order(column: string, options?: {
+        ascending?: boolean;
+        nullsFirst?: boolean;
+    }): QueryBuilder<T, Result>;
+    limit(value: number): QueryBuilder<T, Result>;
+    range(from: number, to: number): QueryBuilder<T, Result>;
+    single(): QueryBuilder<T, T>;
+    maybeSingle(): QueryBuilder<T, T | null>;
+    execute(): Promise<IsomorphResult<Result>>;
+    then<TResult1 = IsomorphResult<Result>, TResult2 = never>(onfulfilled?: ((value: IsomorphResult<Result>) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+}
+export interface RealtimeSubscription {
+    unsubscribe(): void;
+    track(state: Record<string, unknown>): void;
+    presenceState(): Record<string, unknown[]>;
+}
+type RealtimeHandler = (payload: unknown) => void;
+type RealtimeStatus = 'SUBSCRIBED' | 'CLOSED' | 'CHANNEL_ERROR' | 'RECONNECTING' | 'REFETCH_REQUIRED';
+declare class RealtimeChannelBuilder {
+    private readonly channel;
+    private readonly connect;
+    private handlers;
+    constructor(channel: string, connect: (channel: string, handlers: typeof this.handlers, status?: (value: RealtimeStatus) => void) => RealtimeSubscription);
+    on(event: 'postgres_changes' | 'presence' | 'broadcast', filter: unknown, handler: RealtimeHandler): this;
+    subscribe(callback?: (status: RealtimeStatus) => void): RealtimeSubscription;
+}
+export declare function createClient(options?: ClientOptions): {
+    identity: {
+        current: () => Promise<IsomorphUser | null>;
+        signIn: (returnTo?: string) => string;
+        signOut: (returnTo?: string) => string;
+        onChange: (listener: (user: IsomorphUser | null) => void) => () => void;
+    };
+    data: {
+        from: <T = Record<string, unknown>>(table: string) => QueryBuilder<T, T[]>;
+        rpc: <T = unknown>(name: string, args?: Record<string, unknown>) => Promise<T>;
+    };
+    files: {
+        createUpload: (input: {
+            path: string;
+            contentType: string;
+            size: number;
+            checksum?: string;
+        }) => Promise<unknown>;
+        upload: (path: string, body: Blob, checksum?: string) => Promise<unknown>;
+        list: (prefix?: string) => Promise<unknown[]>;
+        remove: (paths: string[]) => Promise<void>;
+        getPublicUrl: (path: string) => string;
+        createSignedUrl: (path: string, expiresIn?: number) => Promise<{
+            signedUrl: string;
+        }>;
+        createSignedUrls: (paths: string[], expiresIn?: number) => Promise<{
+            path: string;
+            signedUrl: string;
+        }[]>;
+    };
+    realtime: {
+        channel: (name: string) => RealtimeChannelBuilder;
+    };
+    actions: {
+        invoke: <T = unknown>(name: string, input: unknown) => Promise<T>;
+    };
+    telemetry: {
+        track: (name: string, properties?: Record<string, unknown>) => Promise<void>;
+        page: (path?: string) => Promise<void>;
+    };
+    integrations: {
+        execute: <R extends IntegrationRequest>(connection: string, request: R) => Promise<IntegrationResult<R>>;
+        connect: (connection: string) => Promise<IntegrationConnectResult>;
+        disconnect: (connection: string) => Promise<IntegrationDisconnectResult>;
+    };
+    ai: {
+        chat: (request: AiChatRequest) => Promise<AiChatResult>;
+        embed: (request: AiEmbedRequest) => Promise<AiEmbedResult>;
+    };
+};
+export type IsomorphClient = ReturnType<typeof createClient>;
+export { IntegrationExecuteInputRules, integrationExecuteInputMaximum, validateIntegrationExecuteInput, type IntegrationExecuteInputFieldRule, type IntegrationExecuteInputProblem, type IntegrationExecuteInputValidation, type IntegrationExecuteOperationRule, type IntegrationExecuteOperation, } from './integration-execute-input-rules.js';
+export { createSupabaseCompatClient, decodeSupabaseCompatResponse, SupabaseCompatQueryBuilder, type SupabaseCompatClient, type SupabaseCompatError, type SupabaseCompatResponse, type SupabaseCompatSession, type SupabaseCompatUser, type SupabaseCompatAuthEvent, type SupabaseCompatFunctionsInvokeOptions, type IsomorphCompatSource, type CompatQuerySource, type CompatChannel, } from './supabase-compat.js';
+/** @deprecated Internal transformation lane only; a kit app uses IsomorphError. */
+export declare const HarbourError: typeof IsomorphError;
+/** @deprecated Internal transformation lane only; a kit app uses IsomorphError. */
+export type HarbourError = IsomorphError;
+/** @deprecated Internal transformation lane only; a kit app uses IsomorphErrorCategory. */
+export type HarbourErrorCategory = IsomorphErrorCategory;
+/** @deprecated Internal transformation lane only; a kit app uses IsomorphUser. */
+export type HarbourUser = IsomorphUser;
+/** @deprecated Internal transformation lane only; a kit app uses IsomorphResult. */
+export type HarbourResult<T> = IsomorphResult<T>;
+/** @deprecated Internal transformation lane only; a kit app uses IsomorphClient. */
+export type HarbourClient = IsomorphClient;
+/** @deprecated Internal transformation lane only; a kit app uses IsomorphCompatSource. */
+export type HarbourCompatSource = import('./supabase-compat.js').IsomorphCompatSource;