@membranehq/sdk 0.9.6 → 0.9.8

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

@@ -9,9 +9,14 @@ export declare enum AgentSessionStatus {
     FAILED = "failed",
     CANCELLED = "cancelled"
 }
+export declare enum AgentSessionState {
+    BUSY = "busy",
+    IDLE = "idle"
+}
 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;
@@ -29,6 +34,7 @@ export declare const AgentSession: z.ZodObject<{
     logs: z.ZodOptional<z.ZodArray<z.ZodAny>>;
     usage: z.ZodOptional<z.ZodNumber>;
     summary: z.ZodOptional<z.ZodString>;
+    state: z.ZodDefault<z.ZodEnum<typeof AgentSessionState>>;
 }, z.core.$strip>;
 export type AgentSession = z.infer<typeof AgentSession>;
 export declare const CreateAgentSession: z.ZodObject<{
@@ -36,6 +42,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<{
@@ -43,3 +50,10 @@ export declare const AgentSessionInputSchema: z.ZodObject<{
     synthetic: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 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>;
+    summary: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<typeof AgentSessionStatus>>;
+}, z.core.$strip>;
+export type PatchAgentSession = z.infer<typeof PatchAgentSessionSchema>;

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

@@ -4,6 +4,7 @@ export declare const membraneConfigSchema: z.ZodObject<{
     workspaceKey: z.ZodString;
     workspaceSecret: z.ZodString;
     apiUri: z.ZodOptional<z.ZodString>;
+    consoleUri: z.ZodOptional<z.ZodString>;
     testCustomerId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type MembraneConfig = z.infer<typeof membraneConfigSchema>;

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/base/actions/index.d.ts

@@ -42,8 +42,8 @@ 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>>>;
     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>;