@membranehq/sdk 0.1.0

package/dist/dts/udm/payments.d.ts

@@ -0,0 +1,3 @@
+import { UnifiedDataModel } from './base';
+declare const udm: UnifiedDataModel;
+export default udm;

package/dist/dts/udm/payrolls.d.ts

@@ -0,0 +1,3 @@
+import { UnifiedDataModel } from './base';
+declare const udm: UnifiedDataModel;
+export default udm;

package/dist/dts/udm/products.d.ts

@@ -0,0 +1,3 @@
+import { UnifiedDataModel } from './base';
+declare const udm: UnifiedDataModel;
+export default udm;

package/dist/dts/udm/projects.d.ts

@@ -0,0 +1,3 @@
+import { UnifiedDataModel } from './base';
+declare const udm: UnifiedDataModel;
+export default udm;

package/dist/dts/udm/suppliers.d.ts

@@ -0,0 +1,3 @@
+import { UnifiedDataModel } from './base';
+declare const udm: UnifiedDataModel;
+export default udm;

package/dist/dts/udm/tasks.d.ts

@@ -0,0 +1,104 @@
+import { UnifiedDataModel } from './base';
+export declare const FIELDS_SCHEMA: {
+    type: string;
+    properties: {
+        id: {
+            type: string;
+            readOnly: boolean;
+        };
+        subject: {
+            type: string;
+        };
+        content: {
+            type: string;
+        };
+        status: {
+            type: string;
+        };
+        type: {
+            type: string;
+        };
+        priority: {
+            type: string;
+        };
+        ownerId: {
+            type: string;
+            referenceUdm: string;
+        };
+        assigneeId: {
+            type: string;
+            referenceUdm: string;
+        };
+        followerIds: {
+            type: string;
+            items: {
+                type: string;
+                referenceUdm: string;
+            };
+        };
+        parentTaskId: {
+            type: string;
+            referenceUdm: string;
+        };
+        projectId: {
+            type: string;
+            referenceUdm: string;
+        };
+        tags: {
+            type: string;
+            items: {
+                type: string;
+            };
+        };
+        contactId: {
+            type: string;
+            referenceUdm: string;
+        };
+        leadId: {
+            type: string;
+            referenceUdm: string;
+        };
+        companyId: {
+            type: string;
+            referenceUdm: string;
+        };
+        dealId: {
+            type: string;
+            referenceUdm: string;
+        };
+        dueTime: {
+            type: string;
+            format: string;
+        };
+        startTime: {
+            type: string;
+            format: string;
+        };
+        endTime: {
+            type: string;
+            format: string;
+        };
+        createdTime: {
+            type: string;
+            format: string;
+            readOnly: boolean;
+        };
+        createdBy: {
+            type: string;
+            referenceUdm: string;
+            readOnly: boolean;
+        };
+        updatedTime: {
+            type: string;
+            format: string;
+            readOnly: boolean;
+        };
+        updatedBy: {
+            type: string;
+            referenceUdm: string;
+            readOnly: boolean;
+        };
+    };
+};
+declare const udm: UnifiedDataModel;
+export default udm;

package/dist/dts/udm/tax-rates.d.ts

@@ -0,0 +1,3 @@
+import { UnifiedDataModel } from './base';
+declare const udm: UnifiedDataModel;
+export default udm;

package/dist/dts/udm/timeoff-balances.d.ts

@@ -0,0 +1,3 @@
+import { UnifiedDataModel } from './base';
+declare const udm: UnifiedDataModel;
+export default udm;

package/dist/dts/udm/timeoff-requests.d.ts

@@ -0,0 +1,3 @@
+import { UnifiedDataModel } from './base';
+declare const udm: UnifiedDataModel;
+export default udm;

package/dist/dts/udm/users.d.ts

@@ -0,0 +1,3 @@
+import { UnifiedDataModel } from './base';
+declare const udm: UnifiedDataModel;
+export default udm;

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

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

package/dist/dts/usage/types.d.ts

@@ -0,0 +1,33 @@
+export declare enum UsageType {
+    FLOW_RUNS_DURATION = "flow-runs-duration",
+    FLOW_RUNS_NUMBER = "flow-runs-number",
+    FLOW_RUNS_LOG_SIZE = "flow-runs-log-size",
+    API_LOGS_NUMBER = "api-logs-number",
+    API_LOGS_SIZE = "api-logs-size",
+    WEBHOOK_LOGS_NUMBER = "webhook-logs-number",
+    WEBHOOK_LOGS_SIZE = "webhook-logs-size",
+    EVENT_LOGS_NUMBER = "event-logs-number",
+    EVENT_LOGS_SIZE = "event-logs-size",
+    EVENT_LOGS_DURATION = "event-logs-duration",
+    EXTERNAL_EVENTS_PULL_DURATION = "external-events-pull-duration",
+    EXTERNAL_EVENT_PULL_NUMBER = "external-event-pull-number",
+    EXTERNAL_EVENT_PULL_LOG_SIZE = "external-event-pull-log-size",
+    APP_EVENTS_NUMBER = "app-events-number",
+    APP_EVENTS_SIZE = "app-events-size",
+    FILES_UPLOAD_NUMBER = "files-upload-number",
+    FILES_UPLOAD_SIZE = "files-upload-size",
+    CUSTOM_CODE_RUNTIME_DURATION = "custom-code-runtime-duration"
+}
+export interface UsageWithCredits {
+    key: UsageType;
+    value: number;
+    credits: number;
+}
+export interface UsageEntry {
+    workspaceId: string;
+    customerId?: string;
+    connectionId?: string;
+    key: UsageType;
+    time: string;
+    value: number;
+}

package/dist/dts/users/accessors.d.ts

@@ -0,0 +1,10 @@
+import { CreateCustomerRequest, CustomerSelector, FindCustomersQuery, UpdateCustomerRequest } from './api';
+import { ElementListAccessor, ElementAccessor } from '../accessors';
+import { IntegrationAppApiClient } from '../api-client';
+import { Customer } from './index';
+export declare class CustomersAccessor extends ElementListAccessor<Customer, FindCustomersQuery, CreateCustomerRequest> {
+    constructor(client: IntegrationAppApiClient);
+}
+export declare class CustomerAccessor extends ElementAccessor<Customer, UpdateCustomerRequest, CustomerSelector> {
+    constructor(client: IntegrationAppApiClient, selector: CustomerSelector | string);
+}

package/dist/dts/users/api.d.ts

@@ -0,0 +1,23 @@
+import { PaginationQuery, SearchQuery } from '../entity-repository';
+export type CreateCustomerRequest = {
+    name?: string;
+    internalId: string;
+    fields?: any;
+    credentials?: any;
+};
+export type UpdateCustomerRequest = {
+    name?: string;
+    internalId?: string;
+    fields?: any;
+    credentials?: any;
+};
+export type FindCustomersQuery = PaginationQuery & SearchQuery & {
+    isTest?: boolean;
+};
+export type CustomerSelector = {
+    id: string;
+};
+export type CreateUserRequest = CreateCustomerRequest;
+export type UpdateUserRequest = UpdateCustomerRequest;
+export type FindUsersQuery = FindCustomersQuery;
+export type UserSelector = CustomerSelector;

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

@@ -0,0 +1,13 @@
+export * from './accessors';
+export * from './api';
+export type Customer = {
+    id: string;
+    name: string;
+    internalId: string;
+    fields?: Record<string, any>;
+    credentials?: any;
+    lastActiveAt?: string;
+    isTest?: boolean;
+    isBillable?: boolean;
+};
+export type User = Customer;

package/dist/dts/variables.d.ts

@@ -0,0 +1,27 @@
+import { DataSchema } from './data-schema';
+import { FlowInstance } from './flows';
+export declare function getNodeInputSchema(flow: FlowInstance, nodeKey: string): any;
+export declare function getFlowNodeConfigTimeVariablesSchema({ parametersSchema, userSchema, }: {
+    parametersSchema: DataSchema;
+    userSchema: DataSchema;
+}): DataSchema;
+export declare function getActionRunTimeVariablesSchema({ inputSchema, userSchema }: {
+    inputSchema: any;
+    userSchema: any;
+}): DataSchema;
+export declare function getActionInstanceVariableSchema(): {
+    type: string;
+    properties: {
+        id: {
+            type: string;
+        };
+        instanceKey: {
+            type: string;
+        };
+    };
+};
+export declare function getFlowNodeRunTimeVariablesSchema({ parametersSchema, inputSchema, userSchema, }: {
+    parametersSchema: DataSchema;
+    inputSchema: DataSchema;
+    userSchema: DataSchema;
+}): DataSchema;

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

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

package/dist/dts/webhooks/types.d.ts

@@ -0,0 +1,11 @@
+export declare enum WebhookTypeEnum {
+    USER_INVITED_TO_ORG = "user-invited-to-org",
+    ORG_ACCESS_REQUESTED = "org-access-requested",
+    ORG_CREATED = "org-created"
+}
+export type WebhookType = WebhookTypeEnum.USER_INVITED_TO_ORG | WebhookTypeEnum.ORG_ACCESS_REQUESTED | WebhookTypeEnum.ORG_CREATED;
+export interface Webhook {
+    type: WebhookType;
+    url: string;
+    secret?: string;
+}

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

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

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

@@ -0,0 +1,77 @@
+import { ErrorData } from '../errors';
+export interface ConfigurationStateResult {
+    state: ConfigurationState;
+    message?: string;
+    errors?: ErrorData[];
+}
+export declare enum ConfigurationState {
+    CONFIGURED = "CONFIGURED",
+    NOT_CONFIGURED = "NOT_CONFIGURED"
+}
+export declare enum WorkspaceElementType {
+    Customer = "customer",
+    Connector = "connector",
+    Integration = "integration",
+    Flow = "flow",
+    FlowInstance = "flow-instance",
+    FlowRun = "flow-run",
+    Action = "action",
+    Scenario = "scenario",
+    ActionInstance = "action-instance",
+    Connection = "connection",
+    FieldMapping = "field-mapping",
+    FieldMappingInstance = "field-mapping-instance",
+    DataSource = "data-source",
+    DataSourceInstance = "data-source-instance",
+    DataLinkTable = "data-link-table",
+    DataLinkTableInstance = "data-link-table-instance",
+    AppEventType = "app-event-type",
+    AppEventSubscription = "app-event-subscription",
+    AppDataSchema = "app-data-schema",
+    AppDataSchemaInstance = "app-data-schema-instance",
+    ExternalEventSubscription = "external-event-subscription",
+    ExternalEventLogRecord = "external-event-log-record",
+    ExternalEventPull = "external-event-pull",
+    DataCollection = "data-collection",
+    Screen = "screen",
+    ActionRunLogRecord = "action-run-log-record"
+}
+export declare enum WorkspaceEventType {
+    ConnectionCreated = "connection.created",
+    ConnectionDeleted = "connection.deleted",
+    ConnectionDisconnected = "connection.disconnected",
+    ConnectionReconnected = "connection.reconnected",
+    FlowRunQueued = "flowRun.queued",
+    FlowRunStarted = "flowRun.started",
+    FlowRunCompleted = "flowRun.completed",
+    FlowRunFailed = "flowRun.failed",
+    FlowRunStopped = "flowRun.stopped"
+}
+export declare enum WorkspaceElementState {
+    CONFIGURATION_ERROR = "CONFIGURATION_ERROR",
+    SETUP_FAILED = "SETUP_FAILED",
+    READY = "READY"
+}
+export declare enum WorkspaceElementDependencyType {
+    Configuration = "CONFIGURATION",
+    Parent = "PARENT"
+}
+export interface WorkspaceElementCalculateStateResult {
+    state: WorkspaceElementState;
+    errors?: ErrorData[];
+}
+export interface WorkspaceElement {
+    id: string;
+    name: string;
+    key: string;
+    state?: WorkspaceElementState;
+    errors?: ErrorData[];
+}
+export interface WorkspaceElementReference {
+    type: WorkspaceElementType;
+    id: string;
+}
+export interface WorkspaceElementDependency extends WorkspaceElementReference {
+    dependencyType: WorkspaceElementDependencyType;
+    data?: unknown;
+}

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

@@ -0,0 +1,27 @@
+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';
+export interface WorkspaceElementSpec {
+    type: WorkspaceElementType;
+    apiPath: string;
+    name: string;
+    namePlural: string;
+    createSchema?: z.ZodObject<any>;
+    updateSchema?: z.ZodObject<any>;
+}
+export interface WorkspaceElements {
+    flows?: Record<string, CreateFlowRequest>;
+    actions?: Record<string, CreateActionRequest>;
+    fieldMappings?: Record<string, CreateFieldMappingRequest>;
+    dataSources?: Record<string, CreateDataSourceRequest>;
+    dataLinkTables?: Record<string, CreateDataLinkTableRequest>;
+    appEventTypes?: Record<string, CreateAppEventTypeRequest>;
+    appDataSchemas?: Record<string, CreateAppDataSchemaRequest>;
+}
+export declare const WorkspaceElementSpecs: Record<WorkspaceElementType, WorkspaceElementSpec>;

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

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

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

@@ -0,0 +1,6 @@
+export interface WorkspaceUpdate {
+    id: string;
+    path: string;
+    before?: unknown;
+    after?: unknown;
+}

package/dist/dts/workspaces/api.d.ts

@@ -0,0 +1,5 @@
+export interface IWorkspaceUpdate {
+    apiBaseUri?: string;
+    apiRequestHeaders: Record<string, any>;
+    apiRequestQuery: Record<string, any>;
+}

package/dist/dts/workspaces/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const PARALLEL_EXECUTION_LIMITS: string[];
+export declare const RATE_LIMITS: string[];
+export declare const WORKSPACE_SIZE_LIMITS: string[];
+export declare const EDITABLE_LIMITS: string[];

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

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

package/dist/dts/workspaces/types.d.ts

@@ -0,0 +1,175 @@
+import { ConnectorAuth, RestApiClientOptions } from '../connectors';
+import { DataSchema } from '../data-schema';
+import { User } from '../users';
+export declare enum WorkspaceOnboardingStep {
+    AddConnectors = "add-connectors",
+    ConnectYourApp = "connect-your-app",
+    BuildIntegrations = "build-integrations",
+    Completed = "completed"
+}
+export interface Workspace {
+    id: string;
+    key: string;
+    secret: string;
+    name: string;
+    orgId: string;
+    engineAccessToken?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    onboardingStep?: WorkspaceOnboardingStep;
+    isGettingStartedCompleted?: boolean;
+    trialEndDate?: string;
+}
+export interface EngineWorkspaceSettings {
+    enableApiLogs?: boolean;
+    enableWebhookLogs?: boolean;
+    enableActionRunLogs?: boolean;
+    disableSecretKeyAuth?: boolean;
+}
+export interface EngineWorkspace {
+    id: string;
+    key: string;
+    logoUri?: string;
+    webhookUri?: string;
+    publicKey?: string;
+    publicKeys?: {
+        name?: string;
+        publicKey: string;
+    }[];
+    enabledWebhookEvents?: string[];
+    userFieldsSchema?: DataSchema;
+    auth?: ConnectorAuth;
+    credentialsSchema?: DataSchema;
+    apiClient?: RestApiClientOptions;
+    apiBaseUri?: string;
+    apiRequestHeaders: Record<string, any>;
+    apiRequestQuery: Record<string, any>;
+    isOnPrem?: boolean;
+    connectorBaseUri?: string;
+    limits: WorkspaceLimits;
+    settings?: EngineWorkspaceSettings;
+    type?: WorkspaceType;
+}
+export interface WorkspaceUser {
+    id: string;
+    workspaceId: string;
+    testCustomerId: string;
+    userId: string;
+    user: User;
+    role: string;
+}
+export interface UserWorkspaceSettings {
+    id: string;
+    userId: string;
+    workspaceId: string;
+    testCustomerId: string;
+}
+export declare enum WorkspaceNotificationType {
+    WorkspaceUpdate = "workspace-update",
+    CopilotActivity = "copilot-activity"
+}
+export interface WorkspaceNotification<DataType = unknown> {
+    type: WorkspaceNotificationType;
+    workspaceId: string;
+    data: DataType;
+}
+export interface CopilotActivityNotificationData {
+    scopes: string[];
+}
+export declare const enum ParallelExecutionLimits {
+    ParallelEventPulls = "parallelEventPulls",
+    ParallelIncrementalEventPullsPerConnection = "parallelIncrementalEventPullsPerConnection",
+    ParallelFullSyncEventPullsPerConnection = "parallelFullSyncEventPullsPerConnection",
+    ParallelFlowRuns = "parallelFlowRuns",
+    ParallelFlowRunsPerConnection = "parallelFlowRunsPerConnection",
+    ParallelApiRequests = "parallelApiRequests",
+    ParallelBackgroundJobs = "parallelBackgroundJobs",
+    ParallelEventLogs = "parallelEventLogs",
+    ParallelEventLogsPerConnection = "parallelEventLogsPerConnection",
+    ParallelWriteDatabaseRequests = "parallelWriteDatabaseRequests"
+}
+export declare const enum RateLimits {
+    fileUploadsMbPerHour = "fileUploadsMbPerHour",
+    ApiRequestsPerSecond = "apiRequestsPerSecond",
+    ApiRequestsPerHour = "apiRequestsPerHour",
+    WebhookRequestsPerSecond = "webhookRequestsPerSecond",
+    WebhookRequestsPerHour = "webhookRequestsPerHour",
+    WorkspaceElementCreationsPerSecond = "workspaceElementCreationsPerSecond",
+    WorkspaceElementCreationsPerHour = "workspaceElementCreationsPerHour",
+    ExternalEventsPerCustomerPerDay = "externalEventsPerCustomerPerDay",
+    CreateDatabaseRequestsPerSecond = "createDatabaseRequestsPerSecond"
+}
+export declare const enum WorkspaceSizeLimits {
+    TotalNumberOfCustomers = "totalNumberOfCustomers",
+    TotalNumberOfConnections = "totalNumberOfConnections",
+    TotalNumberOfWorkspaceElements = "totalNumberOfWorkspaceElements"
+}
+export declare const enum CustomerLimits {
+    ParallelApiRequestsPerCustomer = "parallelApiRequestsPerCustomer",
+    ParallelBackgroundJobsPerCustomer = "parallelBackgroundJobsPerCustomer",
+    ApiRequestsPerCustomerPerSecond = "apiRequestsPerCustomerPerSecond",
+    ApiRequestsPerCustomerPerHour = "apiRequestsPerCustomerPerHour",
+    WebhookRequestsPerCustomerPerSecond = "webhookRequestsPerCustomerPerSecond",
+    WebhookRequestsPerCustomerPerHour = "webhookRequestsPerCustomerPerHour",
+    ParallelWriteDatabaseRequestsPerCustomer = "parallelWriteDatabaseRequestsPerCustomer",
+    CreateDatabaseRequestsPerCustomerPerSecond = "createDatabaseRequestsPerCustomerPerSecond",
+    UpdateDatabaseRequestsPerCustomerPerSecond = "updateDatabaseRequestsPerCustomerPerSecond"
+}
+export declare const enum LimitUnits {
+    Number = "number",
+    Msec = "msec",
+    Mb = "Mb"
+}
+export interface WorkspaceLimit {
+    value?: number;
+    defaultValue?: number;
+    unit: LimitUnits;
+}
+export interface WorkspaceLimits {
+    [ParallelExecutionLimits.ParallelEventPulls]?: WorkspaceLimit;
+    [ParallelExecutionLimits.ParallelIncrementalEventPullsPerConnection]?: WorkspaceLimit;
+    [ParallelExecutionLimits.ParallelFullSyncEventPullsPerConnection]?: WorkspaceLimit;
+    [ParallelExecutionLimits.ParallelFlowRuns]?: WorkspaceLimit;
+    [ParallelExecutionLimits.ParallelFlowRunsPerConnection]?: WorkspaceLimit;
+    [ParallelExecutionLimits.ParallelApiRequests]?: WorkspaceLimit;
+    [ParallelExecutionLimits.ParallelBackgroundJobs]?: WorkspaceLimit;
+    [ParallelExecutionLimits.ParallelEventLogs]?: WorkspaceLimit;
+    [ParallelExecutionLimits.ParallelEventLogsPerConnection]?: WorkspaceLimit;
+    [ParallelExecutionLimits.ParallelWriteDatabaseRequests]?: WorkspaceLimit;
+    [RateLimits.fileUploadsMbPerHour]?: WorkspaceLimit;
+    [RateLimits.ApiRequestsPerSecond]?: WorkspaceLimit;
+    [RateLimits.ApiRequestsPerHour]?: WorkspaceLimit;
+    [RateLimits.WebhookRequestsPerSecond]?: WorkspaceLimit;
+    [RateLimits.WebhookRequestsPerHour]?: WorkspaceLimit;
+    [RateLimits.WorkspaceElementCreationsPerSecond]?: WorkspaceLimit;
+    [RateLimits.WorkspaceElementCreationsPerHour]?: WorkspaceLimit;
+    [RateLimits.ExternalEventsPerCustomerPerDay]?: WorkspaceLimit;
+    [RateLimits.CreateDatabaseRequestsPerSecond]?: WorkspaceLimit;
+    [WorkspaceSizeLimits.TotalNumberOfCustomers]?: WorkspaceLimit;
+    [WorkspaceSizeLimits.TotalNumberOfConnections]?: WorkspaceLimit;
+    [WorkspaceSizeLimits.TotalNumberOfWorkspaceElements]?: WorkspaceLimit;
+    [CustomerLimits.ParallelApiRequestsPerCustomer]?: WorkspaceLimit;
+    [CustomerLimits.ParallelBackgroundJobsPerCustomer]?: WorkspaceLimit;
+    [CustomerLimits.ApiRequestsPerCustomerPerSecond]?: WorkspaceLimit;
+    [CustomerLimits.ApiRequestsPerCustomerPerHour]?: WorkspaceLimit;
+    [CustomerLimits.WebhookRequestsPerCustomerPerSecond]?: WorkspaceLimit;
+    [CustomerLimits.WebhookRequestsPerCustomerPerHour]?: WorkspaceLimit;
+    [CustomerLimits.ParallelWriteDatabaseRequestsPerCustomer]?: WorkspaceLimit;
+    [CustomerLimits.CreateDatabaseRequestsPerCustomerPerSecond]?: WorkspaceLimit;
+    [CustomerLimits.UpdateDatabaseRequestsPerCustomerPerSecond]?: WorkspaceLimit;
+}
+export interface EngineWorkspaceWithOrgData {
+    id: string;
+    key: string;
+    limits: WorkspaceLimits;
+    workspaceId: string;
+    workspaceName: string;
+    orgId: string;
+    orgName: string;
+    type?: WorkspaceType;
+    isTrial: string;
+}
+export declare enum WorkspaceType {
+    PRODUCTION = "production",
+    DEVELOPMENT = "development"
+}