@slflows/sdk 0.0.1

package/dist/v1/index.d.ts

@@ -0,0 +1,414 @@
+interface AppSchema {
+    name?: string;
+    installationInstructions?: string;
+    config?: Record<string, AppConfigField>;
+    onSync?: (input: AppInput) => Promise<AppLifecycleCallbackOutput>;
+    onDrain?: (input: AppInput) => Promise<AppLifecycleCallbackOutput>;
+    draftCustomStatusDescription?: string;
+    onInternalMessage?: (input: AppOnInternalMessageInput) => Promise<void>;
+    blocks: Record<string, AppBlock>;
+    http?: AppHTTPComponent;
+    ui?: AppUIComponent;
+    schedules?: Record<string, AppSchedule>;
+    onTimer?: (input: AppOnTimerInput) => Promise<void>;
+}
+interface AppUIComponent {
+    onRequest: (input: AppOnUIRequestInput) => Promise<any>;
+}
+type SimpleType = "string" | "number" | "boolean" | "any";
+type SimpleTypeArray = [SimpleType];
+interface JsonSchema {
+    type?: string;
+    properties?: Record<string, JsonSchema>;
+    items?: JsonSchema;
+    required?: string[];
+    enum?: (string | number)[];
+    anyOf?: JsonSchema[];
+    oneOf?: JsonSchema[];
+    description?: string;
+    additionalProperties?: boolean;
+}
+type Type = SimpleType | SimpleTypeArray | JsonSchema;
+interface AppConfigField {
+    name: string;
+    description?: string;
+    type: Type;
+    fixed?: boolean;
+    required: boolean;
+    default?: unknown;
+}
+interface AppHTTPComponent {
+    onRequest: (input: AppOnHTTPRequestInput) => Promise<void>;
+}
+type ScheduleDefinition = {
+    type: "cron";
+    cron: {
+        expression: string;
+        location: string;
+    };
+} | {
+    type: "frequency";
+    frequency: {
+        interval: number;
+        unit?: "seconds" | "minutes" | "hours";
+    };
+};
+interface AppSchedule {
+    description?: string;
+    customizable?: boolean;
+    definition: ScheduleDefinition;
+    onTrigger: (input: AppOnTriggerInput) => Promise<void>;
+}
+interface AppBlock {
+    name?: string;
+    description?: string;
+    category?: string;
+    config?: Record<string, AppBlockConfigField>;
+    onInternalMessage?: (input: EntityOnInternalMessageInput) => Promise<void>;
+    inputs?: Record<string, AppBlockComponentInput>;
+    outputs?: Record<string, AppBlockComponentOutput>;
+    signals?: Record<string, AppBlockSignal>;
+    onSync?: (input: EntityInput) => EntityLifecycleCallbackOutput | Promise<EntityLifecycleCallbackOutput>;
+    onDrain?: (input: EntityInput) => EntityLifecycleCallbackOutput | Promise<EntityLifecycleCallbackOutput>;
+    draftCustomStatusDescription?: string;
+    http?: AppBlockHTTPComponent;
+    ui?: AppBlockUIComponent;
+    schedules?: Record<string, AppBlockSchedule>;
+    onTimer?: (input: EntityOnTimerInput) => Promise<void>;
+}
+interface AppBlockConfigField {
+    name: string;
+    description?: string;
+    type: Type;
+    fixed?: boolean;
+    required: boolean;
+    default?: unknown;
+    fieldKey?: string;
+}
+interface AppBlockComponentInput {
+    name?: string;
+    description?: string;
+    config?: Record<string, AppBlockConfigField>;
+    onEvent: (input: EventInput) => Promise<void>;
+}
+interface AppBlockComponentOutput {
+    name?: string;
+    description?: string;
+    default?: boolean;
+    /**
+     * Defines which inputs can provide parent events for this output.
+     * Used for type inference - determines what fields and types will be
+     * available in the output event based on parent input types.
+     * Should be a list of input keys that can be used as parents.
+     */
+    possiblePrimaryParents?: string[];
+    secondary?: boolean;
+    type?: Type;
+}
+interface AppBlockHTTPComponent {
+    onRequest: (input: EntityOnHTTPRequestInput) => Promise<void>;
+}
+interface AppBlockUIComponent {
+    onRequest: (input: EntityOnUIRequestInput) => Promise<any>;
+    views?: EntityView[] | null;
+}
+interface AppBlockSignal {
+    name: string;
+    description: string;
+}
+interface AppBlockSchedule {
+    description?: string;
+    customizable?: boolean;
+    definition: ScheduleDefinition;
+    onTrigger: (input: EntityOnTriggerInput) => Promise<void>;
+}
+interface EntityView {
+    id: string;
+    label: string;
+    type: EntityViewType;
+}
+type EntityViewType = "default" | "fullScreen" | "regular";
+interface AppInput {
+    app: AppContext;
+}
+interface AppContext {
+    config: Record<string, any>;
+    installationStatus: "new" | "active" | "failed";
+    http: AppHTTPEndpoint;
+    installationUrl: string;
+}
+interface AppHTTPEndpoint {
+    url: string;
+}
+interface EntityInput extends AppInput {
+    block: EntityContext;
+}
+interface EntityContext {
+    id: string;
+    config: Record<string, any>;
+    lifecycle: EntityLifecycleComponent | null;
+    http: EntityHTTPEndpoint | null;
+}
+interface EntityLifecycleComponent {
+    status: EntityLifecycleStatus;
+    signals: Record<string, any> | null;
+}
+type EntityLifecycleStatus = "draft" | "in_progress" | "ready" | "drifted" | "failed" | "draining" | "draining_failed" | "drained";
+interface EntityHTTPEndpoint {
+    url: string;
+}
+interface EventInput extends EntityInput {
+    event: EventContext;
+}
+interface EventContext {
+    id: string;
+    inputConfig: Record<string, any>;
+    echo?: {
+        body: any;
+        outputKey: string;
+    };
+}
+interface EntityLifecycleCallbackOutput {
+    signalUpdates?: Record<string, any>;
+    newStatus?: EntityLifecycleStatus;
+    customStatusDescription?: string | null;
+    nextScheduleDelay?: number;
+}
+interface AppLifecycleCallbackOutput {
+    signalUpdates?: Record<string, any>;
+    newStatus?: AppLifecycleStatus;
+    customStatusDescription?: string | null;
+    nextScheduleDelay?: number;
+}
+type AppLifecycleStatus = "draft" | "in_progress" | "ready" | "failed" | "draining" | "draining_failed" | "drained";
+interface AppOnCreateOutput {
+    ok?: {};
+    redirect?: {
+        url: string;
+        method: string;
+    };
+}
+interface AppOnInternalMessageInput extends AppInput {
+    message: {
+        publisherId: string;
+        body: any;
+    };
+}
+interface EntityOnInternalMessageInput extends EntityInput {
+    message: {
+        body: any;
+    };
+}
+interface AppOnTimerInput extends AppInput {
+    timer: {
+        payload: any;
+        prompt?: {
+            id: string;
+            description?: string;
+        };
+    };
+}
+interface EntityOnTimerInput extends EntityInput {
+    timer: {
+        payload: any;
+        pendingEvent?: {
+            id: string;
+            body?: any;
+            status?: string;
+        };
+    };
+}
+interface AppOnTriggerInput extends AppInput {
+    schedule: {
+        time: string;
+    };
+}
+interface EntityOnTriggerInput extends EntityInput {
+    schedule: {
+        time: string;
+    };
+}
+interface AppOnHTTPRequestInput extends AppInput {
+    request: HTTPRequest;
+}
+interface EntityOnHTTPRequestInput extends EntityInput {
+    request: HTTPRequest;
+}
+interface HTTPRequest {
+    requestId: string;
+    path: string;
+    method: string;
+    headers: Record<string, string>;
+    query: Record<string, string>;
+    params: Record<string, string>;
+    rawBody: string;
+    body: any;
+}
+interface AppOnUIRequestInput extends AppInput {
+    request: UIRequest;
+}
+interface EntityOnUIRequestInput extends EntityInput {
+    request: UIRequest;
+}
+interface UIRequest {
+    type: string;
+    payload?: any;
+}
+
+interface KVPair {
+    key: string;
+    value?: any;
+    updatedAt?: number;
+    ttl?: number;
+    lock?: {
+        id: string;
+        timeout?: number;
+    };
+}
+interface KVListInput {
+    keyPrefix: string;
+    startingKey?: string;
+}
+interface KVListOutput {
+    pairs: Array<KVPair>;
+    nextStartingKey?: string;
+}
+interface ListBlocksInput {
+    typeIds?: string[];
+}
+interface ListBlocksOutput {
+    blocks: {
+        id: string;
+        typeId: string;
+        config: Record<string, any>;
+    }[];
+}
+declare const setAppInstallationStatus: (status: "active" | "failed") => Promise<void>;
+interface EmitOptions {
+    outputId?: string;
+    parentEventId?: string;
+    secondaryParentEventIds?: string[];
+    echo?: boolean;
+    complete?: string;
+}
+interface CreatePendingEventOptions {
+    event?: Record<string, any>;
+    outputId?: string;
+    parentEventId?: string;
+    secondaryParentEventIds?: string[];
+    statusDescription: string | null;
+}
+interface UpdatePendingEventOptions {
+    event?: Record<string, any>;
+    outputId?: string;
+    parentEventId?: string;
+    secondaryParentEventIds?: string[];
+    statusDescription?: string | null;
+}
+interface PromptOptions {
+    redirect: {
+        url: string;
+        method: "GET" | "POST";
+        formFields?: Record<string, string>;
+    };
+}
+interface InvocationMetadata {
+    invocationId: string;
+    timestamp: number;
+}
+declare const getInvocationMetadata: () => Promise<InvocationMetadata>;
+declare const events: {
+    emit: (event: any, options?: EmitOptions) => Promise<void>;
+    createPending: (options: CreatePendingEventOptions) => Promise<string>;
+    updatePending: (pendingEventId: string, options: UpdatePendingEventOptions) => Promise<void>;
+    cancelPending: (pendingEventId: string, reason: string) => Promise<void>;
+    completePending: (pendingEventId: string) => Promise<void>;
+};
+declare const kv: {
+    block: {
+        getMany: (keys: string[]) => Promise<KVPair[]>;
+        get: (key: string) => Promise<KVPair>;
+        setMany: (pairs: KVPair[]) => Promise<boolean>;
+        set: (pair: KVPair) => Promise<boolean>;
+        list: (input: KVListInput) => Promise<KVListOutput>;
+        delete: (keys: string[]) => Promise<boolean>;
+        releaseLock: (params: {
+            key: string;
+            lockId: string;
+        }) => Promise<boolean>;
+        renewLock: (params: {
+            key: string;
+            lock: {
+                id: string;
+                timeout?: number;
+            };
+        }) => Promise<boolean>;
+    };
+    app: {
+        getMany: (keys: string[]) => Promise<KVPair[]>;
+        get: (key: string) => Promise<KVPair>;
+        setMany: (pairs: KVPair[]) => Promise<boolean>;
+        set: (pair: KVPair) => Promise<boolean>;
+        list: (input: KVListInput) => Promise<KVListOutput>;
+        delete: (keys: string[]) => Promise<boolean>;
+        releaseLock: (params: {
+            key: string;
+            lockId: string;
+        }) => Promise<boolean>;
+        renewLock: (params: {
+            key: string;
+            lock: {
+                id: string;
+                timeout?: number;
+            };
+        }) => Promise<boolean>;
+    };
+};
+declare const messaging: {
+    sendToBlocks: (input: {
+        body: unknown;
+        blockIds: string[];
+    }) => Promise<void>;
+    sendToApp: (input: {
+        body: unknown;
+    }) => Promise<void>;
+};
+declare const blocks: {
+    list: (input?: ListBlocksInput) => Promise<ListBlocksOutput>;
+};
+declare const http: {
+    respond: (requestId: string, response: {
+        statusCode?: number;
+        headers?: Record<string, string>;
+        body?: unknown;
+    }) => Promise<void>;
+};
+declare const lifecycle: {
+    sync: () => Promise<void>;
+    proceed: () => Promise<void>;
+    prompt: {
+        create: (description: string, options: PromptOptions) => Promise<string>;
+        delete: (promptId: string) => Promise<void>;
+    };
+};
+declare const timers: {
+    set: (delaySeconds: number, options: {
+        inputPayload?: unknown;
+        pendingEventId?: string;
+        promptId?: string;
+        description?: string;
+    }) => Promise<string>;
+    unset: (id: string) => Promise<void>;
+};
+declare const ui: {
+    widget: {
+        set: (options: {
+            blockId?: string;
+            elements: any[] | null;
+        }) => Promise<void>;
+        get: (blockId?: any) => Promise<any[]>;
+    };
+};
+declare function defineApp(app: AppSchema): AppSchema;
+
+export { type AppBlock, type AppBlockComponentInput, type AppBlockComponentOutput, type AppBlockConfigField, type AppBlockHTTPComponent, type AppBlockSchedule, type AppBlockSignal, type AppBlockUIComponent, type AppConfigField, type AppContext, type AppHTTPComponent, type AppHTTPEndpoint, type AppInput, type AppLifecycleCallbackOutput, type AppLifecycleStatus, type AppOnCreateOutput, type AppOnHTTPRequestInput, type AppOnInternalMessageInput, type AppOnTimerInput, type AppOnTriggerInput, type AppOnUIRequestInput, type AppSchedule, type AppSchema, type AppUIComponent, type EntityContext, type EntityHTTPEndpoint, type EntityInput, type EntityLifecycleCallbackOutput, type EntityLifecycleComponent, type EntityLifecycleStatus, type EntityOnHTTPRequestInput, type EntityOnInternalMessageInput, type EntityOnTimerInput, type EntityOnTriggerInput, type EntityOnUIRequestInput, type EntityView, type EntityViewType, type EventContext, type EventInput, type HTTPRequest, type ScheduleDefinition, type UIRequest, blocks, defineApp, events, getInvocationMetadata, http, kv, lifecycle, messaging, setAppInstallationStatus, timers, ui };

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@slflows/sdk",
+  "version": "0.0.1",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    "./v1": "./dist/v1/index.d.ts"
+  },
+  "devDependencies": {
+    "pkgroll": "^2.12.2",
+    "rollup": "^4.41.1",
+    "rollup-plugin-dts": "^6.2.1",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "pkgroll --clean-dist --src types",
+    "watch": "pkgroll --watch --src types"
+  }
+}