@membranehq/sdk 0.9.7 → 0.9.9

package/dist/dts/accessors/base-accessors.d.ts

@@ -1,3 +1,4 @@
+import z from 'zod';
 import { MembraneApiClient } from '../api-client';
 import { PaginationResponse } from '../entity-repository';
 import { WorkspaceElementType } from '../workspace-elements/types';
@@ -12,12 +13,13 @@ export interface ElementInstanceSelector {
     parentKey?: string;
     parentId?: string;
 }
-export interface IntegrationSpecificElementSelector {
-    id?: string;
-    key?: string;
-    integrationId?: string;
-    integrationKey?: string;
-}
+export declare const IntegrationSpecificElementSelector: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    integrationId: z.ZodOptional<z.ZodString>;
+    integrationKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type IntegrationSpecificElementSelector = z.infer<typeof IntegrationSpecificElementSelector>;
 type SelectorType = {
     id?: string;
 } | string;

package/dist/dts/agent/session.d.ts

@@ -15,25 +15,22 @@ export declare enum AgentSessionState {
 }
 export declare const AgentSession: z.ZodObject<{
     id: z.ZodString;
-    workspaceId: z.ZodString;
+    userId: z.ZodOptional<z.ZodString>;
     workspaceElementType: z.ZodEnum<typeof WorkspaceElementType>;
     workspaceElementId: z.ZodString;
     type: z.ZodString;
     status: z.ZodEnum<typeof AgentSessionStatus>;
-    workerId: z.ZodOptional<z.ZodString>;
-    workerUrl: z.ZodOptional<z.ZodString>;
     prompt: z.ZodString;
     error: z.ZodOptional<z.ZodType<ErrorDataSchema, unknown, z.core.$ZodTypeInternals<ErrorDataSchema, unknown>>>;
-    createdBy: z.ZodString;
     lastActivityAt: z.ZodISODateTime;
-    createdAt: z.ZodISODateTime;
-    updatedAt: z.ZodISODateTime;
-    storedMessagesUri: z.ZodOptional<z.ZodString>;
-    sessionFilesZipUri: z.ZodOptional<z.ZodString>;
-    logs: z.ZodOptional<z.ZodArray<z.ZodAny>>;
-    usage: z.ZodOptional<z.ZodNumber>;
+    title: z.ZodOptional<z.ZodString>;
     summary: z.ZodOptional<z.ZodString>;
+    cost: z.ZodOptional<z.ZodNumber>;
     state: z.ZodDefault<z.ZodEnum<typeof AgentSessionState>>;
+    usage: z.ZodOptional<z.ZodNumber>;
+    hasWorker: z.ZodBoolean;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
 }, z.core.$strip>;
 export type AgentSession = z.infer<typeof AgentSession>;
 export declare const CreateAgentSession: z.ZodObject<{
@@ -41,6 +38,7 @@ export declare const CreateAgentSession: z.ZodObject<{
     workspaceElementId: z.ZodOptional<z.ZodString>;
     prompt: z.ZodString;
     testCustomerId: z.ZodOptional<z.ZodString>;
+    isExternal: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type CreateAgentSession = z.infer<typeof CreateAgentSession>;
 export declare const AgentSessionInputSchema: z.ZodObject<{
@@ -51,7 +49,9 @@ export type AgentSessionInput = z.infer<typeof AgentSessionInputSchema>;
 export declare const PatchAgentSessionSchema: z.ZodObject<{
     state: z.ZodOptional<z.ZodEnum<typeof AgentSessionState>>;
     lastActivityAt: z.ZodOptional<z.ZodISODateTime>;
+    title: z.ZodOptional<z.ZodString>;
     summary: z.ZodOptional<z.ZodString>;
+    cost: z.ZodOptional<z.ZodNumber>;
     status: z.ZodOptional<z.ZodEnum<typeof AgentSessionStatus>>;
 }, z.core.$strip>;
 export type PatchAgentSession = z.infer<typeof PatchAgentSessionSchema>;

package/dist/dts/functions/base.d.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export declare enum FunctionType {
+    mapping = "mapping",
+    operationMapping = "operation-mapping",
+    restApiMapping = "rest-api-mapping",
+    graphqlApiMapping = "graphql-api-mapping",
+    javascript = "javascript"
+}
+export declare const BaseFunctionDefinition: z.ZodObject<{
+    type: z.ZodEnum<{
+        mapping: FunctionType.mapping;
+        "operation-mapping": FunctionType.operationMapping;
+        "rest-api-mapping": FunctionType.restApiMapping;
+        "graphql-api-mapping": FunctionType.graphqlApiMapping;
+        javascript: FunctionType.javascript;
+    }>;
+}, z.core.$strip>;
+export type BaseFunctionDefinition = z.infer<typeof BaseFunctionDefinition>;
+export declare const GenericFunctionDefinition: z.ZodObject<{
+    type: z.ZodEnum<{
+        mapping: "mapping";
+        "operation-mapping": "operation-mapping";
+        "rest-api-mapping": "rest-api-mapping";
+        "graphql-api-mapping": "graphql-api-mapping";
+        javascript: "javascript";
+    }>;
+}, z.core.$loose>;
+export type GenericFunctionDefinition = z.infer<typeof GenericFunctionDefinition>;

package/dist/dts/functions/function-types/graphql-api-mapping.d.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { FunctionType } from '../base';
+export declare const GraphQLFieldMappingSchema: z.ZodType<{
+    field: string;
+    args?: Record<string, any>;
+    subFields?: Array<{
+        field: string;
+        args?: Record<string, any>;
+        subFields?: any;
+    }>;
+}>;
+export type GraphQLFieldMappingSchema = z.infer<typeof GraphQLFieldMappingSchema>;
+export declare const GraphQLApiMappingSchema: z.ZodObject<{
+    path: z.ZodString;
+    operationType: z.ZodEnum<{
+        query: "query";
+        mutation: "mutation";
+    }>;
+    requestMapping: z.ZodArray<z.ZodType<{
+        field: string;
+        args?: Record<string, any>;
+        subFields?: Array<{
+            field: string;
+            args?: Record<string, any>;
+            subFields?: any;
+        }>;
+    }, unknown, z.core.$ZodTypeInternals<{
+        field: string;
+        args?: Record<string, any>;
+        subFields?: Array<{
+            field: string;
+            args?: Record<string, any>;
+            subFields?: any;
+        }>;
+    }, unknown>>>;
+    responseMapping: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export type GraphQLApiMappingSchema = z.infer<typeof GraphQLApiMappingSchema>;
+export declare const GraphqlApiMappingFunction: z.ZodObject<{
+    type: z.ZodLiteral<FunctionType.graphqlApiMapping>;
+    mapping: z.ZodObject<{
+        path: z.ZodString;
+        operationType: z.ZodEnum<{
+            query: "query";
+            mutation: "mutation";
+        }>;
+        requestMapping: z.ZodArray<z.ZodType<{
+            field: string;
+            args?: Record<string, any>;
+            subFields?: Array<{
+                field: string;
+                args?: Record<string, any>;
+                subFields?: any;
+            }>;
+        }, unknown, z.core.$ZodTypeInternals<{
+            field: string;
+            args?: Record<string, any>;
+            subFields?: Array<{
+                field: string;
+                args?: Record<string, any>;
+                subFields?: any;
+            }>;
+        }, unknown>>>;
+        responseMapping: z.ZodOptional<z.ZodAny>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type GraphqlApiMappingFunction = z.infer<typeof GraphqlApiMappingFunction>;

package/dist/dts/functions/function-types/index.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+export * from './mapping';
+export * from './operation-mapping';
+export * from './rest-api-mapping';
+export * from './graphql-api-mapping';
+export * from './javascript';
+export declare const FunctionDefinition: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<import("..").FunctionType.mapping>;
+    mapping: z.ZodAny;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<import("..").FunctionType.operationMapping>;
+    mapping: z.ZodObject<{
+        operationKey: z.ZodString;
+        inputMapping: z.ZodOptional<z.ZodAny>;
+        outputMapping: z.ZodOptional<z.ZodAny>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<import("..").FunctionType.restApiMapping>;
+    mapping: z.ZodObject<{
+        path: z.ZodString;
+        method: z.ZodString;
+        requestMapping: z.ZodObject<{
+            pathParameters: z.ZodOptional<z.ZodAny>;
+            query: z.ZodOptional<z.ZodAny>;
+            data: z.ZodOptional<z.ZodAny>;
+            headers: z.ZodOptional<z.ZodAny>;
+        }, z.core.$strip>;
+        responseMapping: z.ZodOptional<z.ZodAny>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<import("..").FunctionType.graphqlApiMapping>;
+    mapping: z.ZodObject<{
+        path: z.ZodString;
+        operationType: z.ZodEnum<{
+            query: "query";
+            mutation: "mutation";
+        }>;
+        requestMapping: z.ZodArray<z.ZodType<{
+            field: string;
+            args?: Record<string, any>;
+            subFields?: Array<{
+                field: string;
+                args?: Record<string, any>;
+                subFields?: any;
+            }>;
+        }, unknown, z.core.$ZodTypeInternals<{
+            field: string;
+            args?: Record<string, any>;
+            subFields?: Array<{
+                field: string;
+                args?: Record<string, any>;
+                subFields?: any;
+            }>;
+        }, unknown>>>;
+        responseMapping: z.ZodOptional<z.ZodAny>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<import("..").FunctionType.javascript>;
+    code: z.ZodString;
+}, z.core.$strip>]>;
+export type FunctionDefinition = z.infer<typeof FunctionDefinition>;

package/dist/dts/functions/function-types/javascript.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { FunctionType } from '../base';
+export declare const JavascriptFunction: z.ZodObject<{
+    type: z.ZodLiteral<FunctionType.javascript>;
+    code: z.ZodString;
+}, z.core.$strip>;
+export type JavascriptFunction = z.infer<typeof JavascriptFunction>;

package/dist/dts/functions/function-types/mapping.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { FunctionType } from '../base';
+export declare const MappingSchema: z.ZodAny;
+export type MappingSchema = z.infer<typeof MappingSchema>;
+export declare const MappingFunction: z.ZodObject<{
+    type: z.ZodLiteral<FunctionType.mapping>;
+    mapping: z.ZodAny;
+}, z.core.$strip>;
+export type MappingFunction = z.infer<typeof MappingFunction>;

package/dist/dts/functions/function-types/operation-mapping.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { FunctionType } from '../base';
+export declare const OperationMappingSchema: z.ZodObject<{
+    operationKey: z.ZodString;
+    inputMapping: z.ZodOptional<z.ZodAny>;
+    outputMapping: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export type OperationMappingSchema = z.infer<typeof OperationMappingSchema>;
+export declare const OperationMappingFunction: z.ZodObject<{
+    type: z.ZodLiteral<FunctionType.operationMapping>;
+    mapping: z.ZodObject<{
+        operationKey: z.ZodString;
+        inputMapping: z.ZodOptional<z.ZodAny>;
+        outputMapping: z.ZodOptional<z.ZodAny>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type OperationMappingFunction = z.infer<typeof OperationMappingFunction>;

package/dist/dts/functions/function-types/rest-api-mapping.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { FunctionType } from '../base';
+export declare const RequestMappingSchema: z.ZodObject<{
+    pathParameters: z.ZodOptional<z.ZodAny>;
+    query: z.ZodOptional<z.ZodAny>;
+    data: z.ZodOptional<z.ZodAny>;
+    headers: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export type RequestMappingSchema = z.infer<typeof RequestMappingSchema>;
+export declare const RestApiMappingSchema: z.ZodObject<{
+    path: z.ZodString;
+    method: z.ZodString;
+    requestMapping: z.ZodObject<{
+        pathParameters: z.ZodOptional<z.ZodAny>;
+        query: z.ZodOptional<z.ZodAny>;
+        data: z.ZodOptional<z.ZodAny>;
+        headers: z.ZodOptional<z.ZodAny>;
+    }, z.core.$strip>;
+    responseMapping: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export type RestApiMappingSchema = z.infer<typeof RestApiMappingSchema>;
+export declare const OpenapiMappingSchema: z.ZodObject<{
+    path: z.ZodString;
+    method: z.ZodString;
+    requestMapping: z.ZodObject<{
+        pathParameters: z.ZodOptional<z.ZodAny>;
+        query: z.ZodOptional<z.ZodAny>;
+        data: z.ZodOptional<z.ZodAny>;
+        headers: z.ZodOptional<z.ZodAny>;
+    }, z.core.$strip>;
+    responseMapping: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export type OpenapiMappingSchema = z.infer<typeof OpenapiMappingSchema>;
+export declare const RestApiMappingFunction: z.ZodObject<{
+    type: z.ZodLiteral<FunctionType.restApiMapping>;
+    mapping: z.ZodObject<{
+        path: z.ZodString;
+        method: z.ZodString;
+        requestMapping: z.ZodObject<{
+            pathParameters: z.ZodOptional<z.ZodAny>;
+            query: z.ZodOptional<z.ZodAny>;
+            data: z.ZodOptional<z.ZodAny>;
+            headers: z.ZodOptional<z.ZodAny>;
+        }, z.core.$strip>;
+        responseMapping: z.ZodOptional<z.ZodAny>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RestApiMappingFunction = z.infer<typeof RestApiMappingFunction>;

package/dist/dts/functions/index.d.ts

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

package/dist/dts/index.browser.d.ts

@@ -30,6 +30,7 @@ export * from './sse';
 export * from './scenario-templates';
 export * from './agent';
 export * from './validation';
+export * from './functions';
 export { MembraneClient as IntegrationAppClient } from './client';
 export { MembraneClient as MembraneClient } from './client';
 export { axios as MembraneAxiosInstance } from './api-client';

package/dist/dts/workspace-elements/api/actions-api.d.ts

@@ -293,7 +293,7 @@ export declare const RunActionRequest: z.ZodObject<{
 export type RunActionRequest = z.infer<typeof RunActionRequest>;
 export declare const ActionRunResponse: z.ZodObject<{
     output: z.ZodOptional<z.ZodAny>;
-    logs: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+    actionRunId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ActionRunResponse<RunOutput = any> = Omit<z.infer<typeof ActionRunResponse>, 'output'> & {
     output: RunOutput;

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

@@ -42,8 +42,9 @@ export declare const ActionExportProperties: z.ZodObject<{
     meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     integrationUuid: z.ZodOptional<z.ZodString>;
     parentUuid: z.ZodOptional<z.ZodString>;
-    inputSchema: z.ZodOptional<z.ZodType<DataSchema, unknown, z.core.$ZodTypeInternals<DataSchema, unknown>>>;
+    isCustomized: z.ZodOptional<z.ZodBoolean>;
     outputMapping: z.ZodOptional<z.ZodAny>;
+    inputSchema: z.ZodOptional<z.ZodType<DataSchema, unknown, z.core.$ZodTypeInternals<DataSchema, unknown>>>;
     customOutputSchema: z.ZodOptional<z.ZodType<DataSchema, unknown, z.core.$ZodTypeInternals<DataSchema, unknown>>>;
 }, z.core.$strip>;
 export type ActionExportProperties = z.infer<typeof ActionExportProperties>;