@membranehq/sdk 0.4.0 → 0.5.0

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

@@ -1,25 +1,68 @@
+import { z } from 'zod';
 import { ActionType } from './action-types';
-import { WorkspaceElementDependency } from '../..';
 import { DataSchema } from '../../../data-schema';
-export interface BaseAction {
-    id: string;
+export declare const BaseAction: z.ZodObject<{
+    id: z.ZodString;
+    key: z.ZodString;
+    name: z.ZodString;
+    revision: z.ZodString;
+    integrationId: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodOptional<z.ZodString>;
+    parentRevision: z.ZodOptional<z.ZodString>;
+    isCustomized: z.ZodOptional<z.ZodBoolean>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    archivedAt: z.ZodOptional<z.ZodString>;
+    type: z.ZodNativeEnum<typeof ActionType>;
+    inputSchema: z.ZodOptional<z.ZodType<DataSchema, z.ZodTypeDef, DataSchema>>;
+    config: z.ZodOptional<z.ZodAny>;
+    outputMapping: z.ZodOptional<z.ZodAny>;
+    customOutputSchema: z.ZodOptional<z.ZodType<DataSchema, z.ZodTypeDef, DataSchema>>;
+    defaultOutputSchema: z.ZodOptional<z.ZodType<DataSchema, z.ZodTypeDef, DataSchema>>;
+    transformedOutputSchema: z.ZodOptional<z.ZodType<DataSchema, z.ZodTypeDef, DataSchema>>;
+    outputSchema: z.ZodOptional<z.ZodType<DataSchema, z.ZodTypeDef, DataSchema>>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+}, "strip", z.ZodTypeAny, {
     key: string;
+    type: ActionType;
+    id: string;
     name: string;
     revision: string;
-    integrationId?: string;
-    parentId?: string;
-    parentRevision?: string;
-    isCustomized?: boolean;
-    createdAt?: string;
-    updatedAt?: string;
-    archivedAt?: string;
+    integrationId?: string | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    archivedAt?: string | undefined;
+    parentId?: string | undefined;
+    parentRevision?: string | undefined;
+    isCustomized?: boolean | undefined;
+    inputSchema?: DataSchema | undefined;
+    config?: any;
+    outputMapping?: any;
+    customOutputSchema?: DataSchema | undefined;
+    defaultOutputSchema?: DataSchema | undefined;
+    transformedOutputSchema?: DataSchema | undefined;
+    outputSchema?: DataSchema | undefined;
+    dependencies?: any[] | undefined;
+}, {
+    key: string;
     type: ActionType;
-    inputSchema?: DataSchema;
+    id: string;
+    name: string;
+    revision: string;
+    integrationId?: string | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    archivedAt?: string | undefined;
+    parentId?: string | undefined;
+    parentRevision?: string | undefined;
+    isCustomized?: boolean | undefined;
+    inputSchema?: DataSchema | undefined;
     config?: any;
     outputMapping?: any;
-    customOutputSchema?: DataSchema;
-    defaultOutputSchema?: DataSchema;
-    transformedOutputSchema?: DataSchema;
-    outputSchema?: DataSchema;
-    dependencies?: WorkspaceElementDependency[];
-}
+    customOutputSchema?: DataSchema | undefined;
+    defaultOutputSchema?: DataSchema | undefined;
+    transformedOutputSchema?: DataSchema | undefined;
+    outputSchema?: DataSchema | undefined;
+    dependencies?: any[] | undefined;
+}>;
+export type BaseAction = z.infer<typeof BaseAction>;

package/dist/dts/workspace-elements/base/app-data-schema-instances/types.d.ts

@@ -1,12 +1,47 @@
-import { ErrorData } from '../../../errors';
-import { BaseMembraneInterface } from '../../types';
-export interface BaseAppDataSchemaInstance extends BaseMembraneInterface {
+import { z } from 'zod';
+export declare const BaseAppDataSchemaInstance: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+} & {
+    key: z.ZodString;
+    state: z.ZodOptional<z.ZodNativeEnum<typeof import("../../types").WorkspaceElementState>>;
+    errors: z.ZodOptional<z.ZodArray<any, "many">>;
+} & {
+    appId: z.ZodString;
+    userId: z.ZodString;
+    appDataSchemaId: z.ZodString;
+    appDataSchemaRevision: z.ZodString;
+    instanceKey: z.ZodOptional<z.ZodString>;
+    schema: z.ZodOptional<z.ZodAny>;
+    error: any;
+    archivedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    id: string;
+    name: string;
+    userId: string;
     appId: string;
+    appDataSchemaId: string;
+    appDataSchemaRevision: string;
+    error?: any;
+    state?: import("../../types").WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    instanceKey?: string | undefined;
+    schema?: any;
+    archivedAt?: string | undefined;
+}, {
+    key: string;
+    id: string;
+    name: string;
     userId: string;
+    appId: string;
     appDataSchemaId: string;
     appDataSchemaRevision: string;
-    instanceKey?: string;
+    error?: any;
+    state?: import("../../types").WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    instanceKey?: string | undefined;
     schema?: any;
-    error?: ErrorData;
-    archivedAt?: string;
-}
+    archivedAt?: string | undefined;
+}>;
+export type BaseAppDataSchemaInstance = z.infer<typeof BaseAppDataSchemaInstance>;

package/dist/dts/workspace-elements/base/app-data-schemas/types.d.ts

@@ -1,7 +1,35 @@
-import { BaseMembraneInterface } from '../../types';
-export interface BaseAppDataSchema extends BaseMembraneInterface {
-    schema: any;
-    code?: string;
-    archivedAt?: string;
-    revision?: string;
-}
+import { z } from 'zod';
+export declare const BaseAppDataSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+} & {
+    key: z.ZodString;
+    state: z.ZodOptional<z.ZodNativeEnum<typeof import("../../types").WorkspaceElementState>>;
+    errors: z.ZodOptional<z.ZodArray<any, "many">>;
+} & {
+    schema: z.ZodAny;
+    code: z.ZodOptional<z.ZodString>;
+    archivedAt: z.ZodOptional<z.ZodString>;
+    revision: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    id: string;
+    name: string;
+    code?: string | undefined;
+    state?: import("../../types").WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    schema?: any;
+    archivedAt?: string | undefined;
+    revision?: string | undefined;
+}, {
+    key: string;
+    id: string;
+    name: string;
+    code?: string | undefined;
+    state?: import("../../types").WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    schema?: any;
+    archivedAt?: string | undefined;
+    revision?: string | undefined;
+}>;
+export type BaseAppDataSchema = z.infer<typeof BaseAppDataSchema>;

package/dist/dts/workspace-elements/base/app-event-subscriptions/types.d.ts

@@ -1,15 +1,84 @@
+import { z } from 'zod';
 import { DataSchema } from '../../../data-schema';
-import { HttpRequestSpec } from '../../../http-requests';
-import { BaseMembraneInterface } from '../../types';
-export interface BaseAppEventSubscription extends BaseMembraneInterface {
+export declare const BaseAppEventSubscription: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+} & {
+    key: z.ZodString;
+    state: z.ZodOptional<z.ZodNativeEnum<typeof import("../../types").WorkspaceElementState>>;
+    errors: z.ZodOptional<z.ZodArray<any, "many">>;
+} & {
+    revision: z.ZodString;
+    appEventTypeId: z.ZodString;
+    userId: z.ZodString;
+    instanceKey: z.ZodOptional<z.ZodString>;
+    isSubscribed: z.ZodBoolean;
+    schema: z.ZodOptional<z.ZodType<DataSchema, z.ZodTypeDef, DataSchema>>;
+    webhookUri: z.ZodString;
+    subscriptionRequest: z.ZodObject<{
+        method: z.ZodOptional<z.ZodNativeEnum<typeof import("../../../http-requests").HttpRequestMethod>>;
+        uri: z.ZodAny;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        body: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        headers?: Record<string, any> | undefined;
+        method?: import("../../../http-requests").HttpRequestMethod | undefined;
+        body?: any;
+        uri?: any;
+        query?: Record<string, any> | undefined;
+    }, {
+        headers?: Record<string, any> | undefined;
+        method?: import("../../../http-requests").HttpRequestMethod | undefined;
+        body?: any;
+        uri?: any;
+        query?: Record<string, any> | undefined;
+    }>;
+    subscriptionResponse: z.ZodOptional<z.ZodAny>;
+    archivedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    id: string;
+    name: string;
+    userId: string;
+    webhookUri: string;
     revision: string;
     appEventTypeId: string;
-    userId: string;
-    instanceKey?: string;
     isSubscribed: boolean;
-    schema?: DataSchema;
+    subscriptionRequest: {
+        headers?: Record<string, any> | undefined;
+        method?: import("../../../http-requests").HttpRequestMethod | undefined;
+        body?: any;
+        uri?: any;
+        query?: Record<string, any> | undefined;
+    };
+    state?: import("../../types").WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    instanceKey?: string | undefined;
+    schema?: DataSchema | undefined;
+    archivedAt?: string | undefined;
+    subscriptionResponse?: any;
+}, {
+    key: string;
+    id: string;
+    name: string;
+    userId: string;
     webhookUri: string;
-    subscriptionRequest: HttpRequestSpec;
+    revision: string;
+    appEventTypeId: string;
+    isSubscribed: boolean;
+    subscriptionRequest: {
+        headers?: Record<string, any> | undefined;
+        method?: import("../../../http-requests").HttpRequestMethod | undefined;
+        body?: any;
+        uri?: any;
+        query?: Record<string, any> | undefined;
+    };
+    state?: import("../../types").WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    instanceKey?: string | undefined;
+    schema?: DataSchema | undefined;
+    archivedAt?: string | undefined;
     subscriptionResponse?: any;
-    archivedAt?: string;
-}
+}>;
+export type BaseAppEventSubscription = z.infer<typeof BaseAppEventSubscription>;

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

@@ -1,12 +1,75 @@
+import { z } from 'zod';
 import { DataSchema } from '../../../data-schema';
-import { HttpRequestSpec } from '../../../http-requests';
-import { BaseMembraneInterface } from '../../types';
-export interface BaseAppEventType extends BaseMembraneInterface {
+export declare const BaseAppEventType: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+} & {
+    key: z.ZodString;
+    state: z.ZodOptional<z.ZodNativeEnum<typeof import("../../types").WorkspaceElementState>>;
+    errors: z.ZodOptional<z.ZodArray<any, "many">>;
+} & {
+    revision: z.ZodString;
+    archivedAt: z.ZodOptional<z.ZodString>;
+    subscribeRequest: z.ZodOptional<z.ZodObject<{
+        method: z.ZodOptional<z.ZodNativeEnum<typeof import("../../../http-requests").HttpRequestMethod>>;
+        uri: z.ZodAny;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        body: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        headers?: Record<string, any> | undefined;
+        method?: import("../../../http-requests").HttpRequestMethod | undefined;
+        body?: any;
+        uri?: any;
+        query?: Record<string, any> | undefined;
+    }, {
+        headers?: Record<string, any> | undefined;
+        method?: import("../../../http-requests").HttpRequestMethod | undefined;
+        body?: any;
+        uri?: any;
+        query?: Record<string, any> | undefined;
+    }>>;
+    example: z.ZodOptional<z.ZodAny>;
+    schema: z.ZodOptional<z.ZodType<DataSchema, z.ZodTypeDef, DataSchema>>;
+    globalWebhookUri: z.ZodString;
+    userIdFormula: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    id: string;
+    name: string;
     revision: string;
-    archivedAt?: string;
-    subscribeRequest?: HttpRequestSpec;
+    globalWebhookUri: string;
+    state?: import("../../types").WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    schema?: DataSchema | undefined;
+    archivedAt?: string | undefined;
+    subscribeRequest?: {
+        headers?: Record<string, any> | undefined;
+        method?: import("../../../http-requests").HttpRequestMethod | undefined;
+        body?: any;
+        uri?: any;
+        query?: Record<string, any> | undefined;
+    } | undefined;
     example?: any;
-    schema?: DataSchema;
+    userIdFormula?: any;
+}, {
+    key: string;
+    id: string;
+    name: string;
+    revision: string;
     globalWebhookUri: string;
+    state?: import("../../types").WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    schema?: DataSchema | undefined;
+    archivedAt?: string | undefined;
+    subscribeRequest?: {
+        headers?: Record<string, any> | undefined;
+        method?: import("../../../http-requests").HttpRequestMethod | undefined;
+        body?: any;
+        uri?: any;
+        query?: Record<string, any> | undefined;
+    } | undefined;
+    example?: any;
     userIdFormula?: any;
-}
+}>;
+export type BaseAppEventType = z.infer<typeof BaseAppEventType>;

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

@@ -1,33 +1,89 @@
-import { ErrorData } from '../../../errors';
-import { BaseWorkspaceElement, WorkspaceElementState } from '../../types';
+import { z } from 'zod';
+import { WorkspaceElementState } from '../../types';
 import { ConnectorUiSpec, ConnectorSpec } from '../connectors/types';
-export interface ConnectionRequest {
-    path: any;
-    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    pathParameters?: Record<string, string>;
-    headers?: Record<string, string>;
-    query?: Record<string, string>;
+export declare const ConnectionRequest: z.ZodObject<{
+    path: z.ZodAny;
+    method: z.ZodOptional<z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>>;
+    pathParameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    data: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    headers?: Record<string, string> | undefined;
+    method?: "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | undefined;
     data?: any;
-}
-export interface BaseConnection extends BaseWorkspaceElement {
+    path?: any;
+    query?: Record<string, string> | undefined;
+    pathParameters?: Record<string, string> | undefined;
+}, {
+    headers?: Record<string, string> | undefined;
+    method?: "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | undefined;
+    data?: any;
+    path?: any;
+    query?: Record<string, string> | undefined;
+    pathParameters?: Record<string, string> | undefined;
+}>;
+export type ConnectionRequest = z.infer<typeof ConnectionRequest>;
+export declare const BaseConnection: z.ZodObject<{
+    id: z.ZodString;
+} & {
+    name: z.ZodString;
+    userId: z.ZodString;
+    disconnected: z.ZodOptional<z.ZodBoolean>;
+    error: any;
+    integrationId: z.ZodString;
+    credentials: z.ZodOptional<z.ZodUnknown>;
+    parameters: z.ZodOptional<z.ZodUnknown>;
+    connectorParameters: z.ZodOptional<z.ZodUnknown>;
+    accessToken: z.ZodOptional<z.ZodString>;
+    refreshToken: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    lastActiveAt: z.ZodOptional<z.ZodString>;
+    nextCredentialsRefreshAt: z.ZodOptional<z.ZodString>;
+    archivedAt: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodNativeEnum<typeof WorkspaceElementState>>;
+    errors: z.ZodOptional<z.ZodArray<any, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
     name: string;
     userId: string;
-    disconnected?: boolean;
-    error?: ErrorData;
     integrationId: string;
+    createdAt: string;
+    updatedAt: string;
+    error?: any;
+    state?: WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    accessToken?: string | undefined;
     credentials?: unknown;
     parameters?: unknown;
     connectorParameters?: unknown;
-    accessToken?: string;
-    refreshToken?: string;
+    disconnected?: boolean | undefined;
+    refreshToken?: string | undefined;
+    lastActiveAt?: string | undefined;
+    nextCredentialsRefreshAt?: string | undefined;
+    archivedAt?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    userId: string;
+    integrationId: string;
     createdAt: string;
     updatedAt: string;
-    lastActiveAt?: string;
-    nextCredentialsRefreshAt?: string;
-    archivedAt?: string;
-    state?: WorkspaceElementState;
-    errors?: ErrorData[];
-}
+    error?: any;
+    state?: WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    accessToken?: string | undefined;
+    credentials?: unknown;
+    parameters?: unknown;
+    connectorParameters?: unknown;
+    disconnected?: boolean | undefined;
+    refreshToken?: string | undefined;
+    lastActiveAt?: string | undefined;
+    nextCredentialsRefreshAt?: string | undefined;
+    archivedAt?: string | undefined;
+}>;
+export type BaseConnection = z.infer<typeof BaseConnection>;
 export interface ConnectionSpec extends ConnectorSpec {
 }
 export type ConnectionUiSpec = ConnectorUiSpec;

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

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 import { ConnectorAuth } from './auth';
 import { ConnectorMethodImplementation } from './methods';
 import { ConnectorOperationHandler } from './operations';
@@ -56,9 +57,20 @@ export interface ConnectorSpec {
     workspaceId?: string;
     data?: any;
 }
-export type MinimalConnector = {
+export declare const MinimalConnector: z.ZodObject<{
+    id: z.ZodString;
+    key: z.ZodString;
+    name: z.ZodString;
+    logoUri: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    key: string;
     id: string;
+    name: string;
+    logoUri: string;
+}, {
     key: string;
+    id: string;
     name: string;
     logoUri: string;
-};
+}>;
+export type MinimalConnector = z.infer<typeof MinimalConnector>;

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

@@ -1,10 +1,30 @@
-export type BaseCustomer = {
+import { z } from 'zod';
+export declare const BaseCustomer: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    internalId: z.ZodString;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    credentials: z.ZodOptional<z.ZodAny>;
+    lastActiveAt: z.ZodOptional<z.ZodString>;
+    isTest: z.ZodOptional<z.ZodBoolean>;
+    isBillable: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
     id: string;
     name: string;
     internalId: string;
-    fields?: Record<string, any>;
     credentials?: any;
-    lastActiveAt?: string;
-    isTest?: boolean;
-    isBillable?: boolean;
-};
+    fields?: Record<string, any> | undefined;
+    lastActiveAt?: string | undefined;
+    isTest?: boolean | undefined;
+    isBillable?: boolean | undefined;
+}, {
+    id: string;
+    name: string;
+    internalId: string;
+    credentials?: any;
+    fields?: Record<string, any> | undefined;
+    lastActiveAt?: string | undefined;
+    isTest?: boolean | undefined;
+    isBillable?: boolean | undefined;
+}>;
+export type BaseCustomer = z.infer<typeof BaseCustomer>;