@membranehq/sdk 0.2.1 → 0.4.0

package/dist/dts/workspace-elements/base/flow-runs/flow-node-runs.d.ts

@@ -0,0 +1,374 @@
+import { z } from 'zod';
+import { ErrorData } from '../../../errors';
+export declare enum FlowNodeRunStatus {
+    COMPLETED = "completed",
+    FAILED = "failed",
+    SKIPPED = "skipped"
+}
+export interface FlowNodeHandlerRunResponse {
+    status?: FlowNodeRunStatus;
+    output?: any;
+    errors?: ErrorData[];
+}
+export declare const UpstreamFlowNodeRunSchema: z.ZodObject<{
+    nodeKey: z.ZodString;
+    runId: z.ZodString;
+    outputId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    nodeKey: string;
+    runId: string;
+    outputId: string;
+}, {
+    nodeKey: string;
+    runId: string;
+    outputId: string;
+}>;
+export interface UpstreamFlowNodeRun extends z.infer<typeof UpstreamFlowNodeRunSchema> {
+}
+export declare const DownstreamFlowNodeRunSchema: z.ZodObject<{
+    runId: z.ZodString;
+    nodeKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    nodeKey: string;
+    runId: string;
+}, {
+    nodeKey: string;
+    runId: string;
+}>;
+export interface DownstreamFlowNodeRun extends z.infer<typeof DownstreamFlowNodeRunSchema> {
+}
+export declare const FlowNodeRunParametersSchema: z.ZodObject<{
+    id: z.ZodString;
+    upstreamRuns: z.ZodArray<z.ZodObject<{
+        nodeKey: z.ZodString;
+        runId: z.ZodString;
+        outputId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }, {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }>, "many">;
+    input: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    upstreamRuns: {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }[];
+    input?: any;
+}, {
+    id: string;
+    upstreamRuns: {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }[];
+    input?: any;
+}>;
+export interface FlowNodeRunParameters extends z.infer<typeof FlowNodeRunParametersSchema> {
+}
+export declare const FlowNodeRunOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    data: z.ZodString;
+    downstreamRuns: z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        nodeKey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        nodeKey: string;
+        runId: string;
+    }, {
+        nodeKey: string;
+        runId: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    data: string;
+    id: string;
+    downstreamRuns: {
+        nodeKey: string;
+        runId: string;
+    }[];
+}, {
+    data: string;
+    id: string;
+    downstreamRuns: {
+        nodeKey: string;
+        runId: string;
+    }[];
+}>;
+export interface FlowNodeRunOutput extends z.infer<typeof FlowNodeRunOutputSchema> {
+}
+export declare const FlowNodeRunResultSchema: z.ZodObject<{
+    status: z.ZodNativeEnum<typeof FlowNodeRunStatus>;
+    logs: z.ZodArray<z.ZodAny, "many">;
+    outputs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        data: z.ZodString;
+        downstreamRuns: z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            nodeKey: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            nodeKey: string;
+            runId: string;
+        }, {
+            nodeKey: string;
+            runId: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        data: string;
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }, {
+        data: string;
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }>, "many">;
+    errors: z.ZodArray<any, "many">;
+}, "strip", z.ZodTypeAny, {
+    logs: any[];
+    status: FlowNodeRunStatus;
+    errors: any[];
+    outputs: {
+        data: string;
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }[];
+}, {
+    logs: any[];
+    status: FlowNodeRunStatus;
+    errors: any[];
+    outputs: {
+        data: string;
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }[];
+}>;
+export interface FlowNodeRunResult extends z.infer<typeof FlowNodeRunResultSchema> {
+}
+export declare const FlowNodeRunRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    upstreamRuns: z.ZodArray<z.ZodObject<{
+        nodeKey: z.ZodString;
+        runId: z.ZodString;
+        outputId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }, {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }>, "many">;
+    input: z.ZodAny;
+} & {
+    status: z.ZodNativeEnum<typeof FlowNodeRunStatus>;
+    logs: z.ZodArray<z.ZodAny, "many">;
+    outputs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        data: z.ZodString;
+        downstreamRuns: z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            nodeKey: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            nodeKey: string;
+            runId: string;
+        }, {
+            nodeKey: string;
+            runId: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        data: string;
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }, {
+        data: string;
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }>, "many">;
+    errors: z.ZodArray<any, "many">;
+}, "strip", z.ZodTypeAny, {
+    logs: any[];
+    status: FlowNodeRunStatus;
+    id: string;
+    errors: any[];
+    upstreamRuns: {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }[];
+    outputs: {
+        data: string;
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }[];
+    input?: any;
+}, {
+    logs: any[];
+    status: FlowNodeRunStatus;
+    id: string;
+    errors: any[];
+    upstreamRuns: {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }[];
+    outputs: {
+        data: string;
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }[];
+    input?: any;
+}>;
+export interface FlowNodeRunRecord extends z.infer<typeof FlowNodeRunRecordSchema> {
+}
+export declare const FlowNodeRunOutputWithoutDownstreamRunsSchema: z.ZodObject<{
+    id: z.ZodString;
+    data: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    data: string;
+    id: string;
+}, {
+    data: string;
+    id: string;
+}>;
+export interface FlowNodeRunOutputWithoutDownstreamRuns extends z.infer<typeof FlowNodeRunOutputWithoutDownstreamRunsSchema> {
+}
+export declare const FlowNodeRunOutputMetadataSchema: z.ZodObject<{
+    id: z.ZodString;
+    downstreamRuns: z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        nodeKey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        nodeKey: string;
+        runId: string;
+    }, {
+        nodeKey: string;
+        runId: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    downstreamRuns: {
+        nodeKey: string;
+        runId: string;
+    }[];
+}, {
+    id: string;
+    downstreamRuns: {
+        nodeKey: string;
+        runId: string;
+    }[];
+}>;
+export interface FlowNodeRunOutputMetadata extends z.infer<typeof FlowNodeRunOutputMetadataSchema> {
+}
+export declare const FlowNodeRunRecordWithoutOutputsDataSchema: z.ZodObject<{
+    id: z.ZodString;
+    upstreamRuns: z.ZodArray<z.ZodObject<{
+        nodeKey: z.ZodString;
+        runId: z.ZodString;
+        outputId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }, {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }>, "many">;
+    input: z.ZodAny;
+    status: z.ZodNativeEnum<typeof FlowNodeRunStatus>;
+    logs: z.ZodArray<z.ZodAny, "many">;
+    outputs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        downstreamRuns: z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            nodeKey: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            nodeKey: string;
+            runId: string;
+        }, {
+            nodeKey: string;
+            runId: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }, {
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }>, "many">;
+    errors: z.ZodArray<any, "many">;
+}, "strip", z.ZodTypeAny, {
+    logs: any[];
+    status: FlowNodeRunStatus;
+    id: string;
+    errors: any[];
+    upstreamRuns: {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }[];
+    outputs: {
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }[];
+    input?: any;
+}, {
+    logs: any[];
+    status: FlowNodeRunStatus;
+    id: string;
+    errors: any[];
+    upstreamRuns: {
+        nodeKey: string;
+        runId: string;
+        outputId: string;
+    }[];
+    outputs: {
+        id: string;
+        downstreamRuns: {
+            nodeKey: string;
+            runId: string;
+        }[];
+    }[];
+    input?: any;
+}>;
+export interface FlowNodeRunRecordWithoutOutputsData extends z.infer<typeof FlowNodeRunRecordWithoutOutputsDataSchema> {
+}

package/dist/dts/workspace-elements/base/flow-runs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './flow-node-runs';

package/dist/dts/workspace-elements/base/flow-runs/types.d.ts

@@ -0,0 +1,31 @@
+import { ErrorData } from '../../../errors';
+import { FlowRunState, FlowRunLaunchedBy } from '../../api/flow-runs-api';
+export declare enum FlowRunNodeState {
+    RUNNING = "running",
+    COMPLETED = "completed",
+    STOPPED = "stopped",
+    FAILED = "failed"
+}
+export interface BaseFlowRun {
+    id: string;
+    name?: string;
+    flowInstanceId: string;
+    universalFlowId?: string;
+    connectionId?: string;
+    integrationId?: string;
+    startNodeKey: string;
+    userId: string;
+    input?: any;
+    state: FlowRunState;
+    startTime: string;
+    endTime?: string;
+    errors?: ErrorData[];
+    nodes?: Record<string, FlowRunNode>;
+    launchedBy?: FlowRunLaunchedBy;
+}
+export interface FlowRunNode {
+    state: FlowRunNodeState;
+    runs?: number;
+    erroredRuns?: number;
+    outputs?: number;
+}

package/dist/dts/workspace-elements/base/flows/index.d.ts

@@ -0,0 +1,2 @@
+export * from './nodes';
+export * from './types';

package/dist/dts/workspace-elements/base/flows/types.d.ts

@@ -0,0 +1,33 @@
+import { DataSchema } from '../../../data-schema';
+import { BaseMembraneInterface } from '../../types';
+export interface FlowNode {
+    type?: string;
+    version?: number;
+    name?: string;
+    description?: string;
+    config?: any;
+    concurrency?: number;
+    onError?: 'stop' | 'continue';
+    ui?: any;
+    inputSchema?: any;
+    outputSchema?: any;
+    outputExample?: any;
+    links?: FlowNodeLink[];
+    isCustomized?: boolean;
+}
+export interface BaseFlow extends BaseMembraneInterface {
+    integrationId?: string;
+    universalFlowId?: string;
+    universalFlowRevision?: string;
+    parametersSchema?: DataSchema;
+    nodes?: Record<string, FlowNode>;
+    autoCreateInstances?: boolean;
+    archivedAt?: string;
+    revision: string;
+    customized?: boolean;
+}
+export interface FlowNodeLink {
+    key?: string;
+    filter?: any;
+    name?: string;
+}

package/dist/dts/workspace-elements/base/index.d.ts

@@ -0,0 +1,27 @@
+export * from './actions';
+export * from './connections';
+export * from './connectors';
+export * from './data-collections';
+export * from './data-sources';
+export * from './data-source-instances';
+export * from './external-events';
+export * from './flow-runs';
+export * from './flows';
+export * from './integrations';
+export * from './scenarios';
+export * from './screens';
+export * from './customers';
+export * from './flow-instances';
+export * from './action-instances';
+export * from './field-mappings';
+export * from './field-mapping-instances';
+export * from './data-link-tables';
+export * from './data-link-table-instances';
+export * from './app-event-types';
+export * from './app-event-subscriptions';
+export * from './app-data-schemas';
+export * from './app-data-schema-instances';
+export * from './external-event-subscriptions';
+export * from './external-event-log-records';
+export * from './external-event-pulls';
+export * from './action-run-log-records';

package/dist/dts/workspace-elements/base/integrations/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

package/dist/dts/{integrations → workspace-elements/base/integrations}/types.d.ts

@@ -1,11 +1,7 @@
-import { Connection } from '../connections';
-import { ConnectorAuthSpec, ConnectorAuthType, ConnectorSpec } from '../connectors';
-import { DataSchema } from '../data-schema';
-import { ErrorData } from '../errors';
-import { WorkspaceElement, WorkspaceElementState } from '../workspace-elements';
-export interface Integration extends WorkspaceElement {
-    state?: WorkspaceElementState;
-    errors?: ErrorData[];
+import { BaseMembraneInterface } from '../..';
+import { DataSchema } from '../../../data-schema';
+import { ConnectorAuthSpec, ConnectorAuthType } from '../connectors';
+export interface BaseIntegration extends BaseMembraneInterface {
     logoUri: string;
     connectorId?: string;
     connectorVersion?: string;
@@ -14,9 +10,7 @@ export interface Integration extends WorkspaceElement {
     parametersSchema?: DataSchema;
     parameters?: any;
     baseUri: string;
-    connection?: Connection;
     archivedAt?: string;
-    spec?: ConnectorSpec;
     hasMissingParameters?: boolean;
     hasDocumentation?: boolean;
     hasOperations?: boolean;
@@ -34,5 +28,5 @@ export type IntegrationAuthOption = ConnectorAuthSpec & {
 };
 export type AppliedToIntegrations<Element> = {
     element: Element;
-    integration: Integration;
+    integration: BaseIntegration;
 }[];

package/dist/dts/workspace-elements/base/scenarios/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

package/dist/dts/workspace-elements/base/scenarios/types.d.ts

@@ -0,0 +1,27 @@
+import { BaseMembraneInterface } from '../..';
+import { ScenarioElement, ScenarioToDo, ScenarioTemplateElements, HandyScenarioTemplateElement, ScenarioTemplateCategory } from '../../api/scenarios-api';
+import { MinimalConnector } from '../connectors';
+export interface BaseScenario extends BaseMembraneInterface {
+    appId: string;
+    scenarioTemplateId?: string;
+    elements?: ScenarioElement[];
+    connectors?: MinimalConnector[];
+    todos?: ScenarioToDo[];
+    archivedAt?: string;
+}
+export interface ScenarioTemplate {
+    id: string;
+    name: string;
+    key: string;
+    shortDescription?: string;
+    description?: string;
+    demoWorkspaceKey?: string;
+    demoAppUri?: string;
+    demoGithubRepo?: string;
+    demoVideoYoutubeUri?: string;
+    tags?: ScenarioTemplateCategory[];
+    elements?: ScenarioTemplateElements;
+    todos?: Omit<ScenarioToDo, 'isComplete'>[];
+    connectors?: MinimalConnector[];
+    handyElements?: HandyScenarioTemplateElement[];
+}

package/dist/dts/workspace-elements/base/screens/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

package/dist/dts/workspace-elements/base/screens/types.d.ts

@@ -0,0 +1,7 @@
+import { BaseWorkspaceElement } from '../..';
+import { ScreenType, ScreenBlock } from '../../api/screens-api';
+export interface BaseScreen extends BaseWorkspaceElement {
+    type: ScreenType;
+    key?: string;
+    blocks: ScreenBlock[];
+}

package/dist/dts/workspace-elements/errors.d.ts

@@ -0,0 +1,5 @@
+import { ErrorConstructorArg, IntegrationAppError } from '../errors';
+import { WorkspaceElementReference } from './types';
+export declare class DependencyError extends IntegrationAppError {
+    constructor(arg: ErrorConstructorArg, workspaceElementReference?: WorkspaceElementReference);
+}

package/dist/dts/workspace-elements/index.d.ts

@@ -1 +1,5 @@
+export * from './base';
 export * from './types';
+export * from './api';
+export * from './errors';
+export * from './utils';

package/dist/dts/workspace-elements/types.d.ts

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 import { ErrorData } from '../errors';
 export interface ConfigurationStateResult {
     state: ConfigurationState;
@@ -60,13 +61,38 @@ export interface WorkspaceElementCalculateStateResult {
     state: WorkspaceElementState;
     errors?: ErrorData[];
 }
-export interface WorkspaceElement {
+export declare const BaseWorkspaceElement: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
     id: string;
     name: string;
+}, {
+    id: string;
+    name: string;
+}>;
+export type BaseWorkspaceElement = z.infer<typeof BaseWorkspaceElement>;
+export declare const BaseMembraneInterface: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+} & {
+    key: z.ZodString;
+    state: z.ZodOptional<z.ZodNativeEnum<typeof WorkspaceElementState>>;
+    errors: z.ZodOptional<z.ZodArray<any, "many">>;
+}, "strip", z.ZodTypeAny, {
     key: string;
-    state?: WorkspaceElementState;
-    errors?: ErrorData[];
-}
+    id: string;
+    name: string;
+    state?: WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+}, {
+    key: string;
+    id: string;
+    name: string;
+    state?: WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+}>;
+export type BaseMembraneInterface = z.infer<typeof BaseMembraneInterface>;
 export interface WorkspaceElementReference {
     type: WorkspaceElementType;
     id: string;

package/dist/dts/{flows/utils.d.ts → workspace-elements/utils/flow-utils.d.ts}

@@ -1,6 +1,6 @@
-import { FlowNodeSpec } from './nodes';
-import { IntegrationElementInstance, IntegrationElementType } from '../integration-elements';
-import { Flow, FlowInstance, FlowInstanceNode, FlowNode } from '.';
+import { IntegrationElementType, IntegrationElementInstance } from '../../integration-elements';
+import { Flow, FlowInstance } from '../api';
+import { FlowNode, FlowNodeSpec, FlowInstanceNode } from '../base';
 export declare function getFlowNode(flow: Flow | FlowInstance, nodeKey: string): FlowNode;
 export declare function getFlowNodeTitle(flow: Flow | FlowInstance, nodeKey: string): string | undefined;
 export declare function getFlowNodeDescription(flow: Flow | FlowInstance, nodeKey: string): string | undefined;

package/dist/dts/workspace-elements/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './flow-utils';

package/dist/dts/workspace-elements-catalog/index.d.ts

@@ -1,12 +1,7 @@
 import { z } from 'zod';
-import { CreateActionRequest } from '../actions';
-import { CreateAppDataSchemaRequest } from '../app-data-schemas';
-import { CreateAppEventTypeRequest } from '../app-events';
-import { CreateDataLinkTableRequest } from '../data-links';
-import { CreateDataSourceRequest } from '../data-sources';
-import { CreateFieldMappingRequest } from '../field-mappings';
-import { CreateFlowRequest } from '../flows';
-import { WorkspaceElementType } from '../workspace-elements';
+import { CreateAppDataSchemaRequest, CreateAppEventTypeRequest, CreateDataLinkTableRequest, CreateFieldMappingRequest } from '../workspace-elements';
+import { CreateActionRequest, CreateDataSourceRequest, CreateFlowRequest } from '../workspace-elements/api';
+import { WorkspaceElementType } from '../workspace-elements/types';
 export interface WorkspaceElementSpec {
     type: WorkspaceElementType;
     apiPath: string;