@membranehq/sdk 0.2.1 → 0.4.0

package/dist/bundle.d.ts

@@ -18,11 +18,11 @@ declare class IntegrationAppApiClient {
     constructor({ uiUri, apiUri, accessToken, token, fetchToken, fetchCredentials, credentials, }?: IntegrationAppClientOptions);
     setCredentials(credentials: any): Promise<any>;
     getToken(): Promise<string>;
-    get(uri: string, queryParams?: Record<string, any>, options?: AxiosRequestConfig): Promise<any>;
-    post(uri: string, data?: any, options?: AxiosRequestConfig): Promise<any>;
-    put(uri: string, data?: any, options?: AxiosRequestConfig): Promise<any>;
-    patch(uri: string, data?: any, options?: AxiosRequestConfig): Promise<any>;
-    delete(uri: string, data?: any, options?: AxiosRequestConfig): Promise<any>;
+    get<T = any>(uri: string, queryParams?: Record<string, any>, options?: AxiosRequestConfig): Promise<T>;
+    post<T = any>(uri: string, data?: any, options?: AxiosRequestConfig): Promise<T>;
+    put<T = any>(uri: string, data?: any, options?: AxiosRequestConfig): Promise<T>;
+    patch<T = any>(uri: string, data?: any, options?: AxiosRequestConfig): Promise<T>;
+    delete<T = any>(uri: string, data?: any, options?: AxiosRequestConfig): Promise<T>;
     getEmbedUri(page: string, pageParams?: Record<string, any>, options?: {
         embedMode: 'isolated-embed' | 'popup-embed';
     }): Promise<string>;
@@ -55,37 +55,8 @@ declare class PaginationResponse<T> {
     cursor?: string;
 }
 
-declare enum ErrorDoc {
-    AuthenticationTokenErrors = "authentication-token-errors",
-    DataSourceNoCollectionSelected = "data-source-no-collection-selected",
-    FlowInstanceSetupFailed = "flow-instance-setup-failed",
-    FlowInstanceSetupTimeout = "flow-instance-setup-timeout",
-    WebhookCannotFindUser = "webhook-cannot-find-user"
-}
-
-declare enum ErrorType {
-    BAD_REQUEST = "bad_request",
-    CONNECTION = "connection",
-    CONFIGURATION = "configuration",
-    DEPENDENCY_ERROR = "dependency_error",
-    FLOW_RUN = "flow_run",
-    FLOW_INSTANCE_SETUP = "flow_instance_setup",
-    CONCURRENCY = "concurrency",
-    INTERNAL = "internal",
-    ACTION_RUN = "action_run",
-    ACTION_INSTANCE_SETUP = "action_instance_setup",
-    UNIT_RUN = "unit_run",
-    CUSTOM_CODE = "custom_code"
-}
-interface ErrorDataFields {
-    type?: ErrorType;
-    key?: string;
-    message: string;
-    data?: any;
-    doc?: ErrorDoc;
-    stack?: any;
-    causedByError?: ErrorData;
-    logs?: any[];
+declare const ErrorDataSchema: any;
+interface ErrorDataFields extends z.infer<typeof ErrorDataSchema> {
 }
 type ErrorConstructorArg = string | ErrorDataFields | Error;
 declare class ErrorData implements ErrorDataFields {
@@ -131,13 +102,38 @@ declare enum WorkspaceElementDependencyType {
     Configuration = "CONFIGURATION",
     Parent = "PARENT"
 }
-interface WorkspaceElement {
+declare const BaseWorkspaceElement: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
     id: string;
     name: string;
+}, {
+    id: string;
+    name: string;
+}>;
+type BaseWorkspaceElement = z.infer<typeof BaseWorkspaceElement>;
+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;
+}>;
+type BaseMembraneInterface = z.infer<typeof BaseMembraneInterface>;
 interface WorkspaceElementReference {
     type: WorkspaceElementType;
     id: string;
@@ -229,85 +225,28 @@ declare class ElementInstanceAccessor<ElementInstance extends BaseElementInstanc
     private getSelector;
 }
 
-interface FindConnectionsQuery extends PaginationQuery {
-    userId?: string;
-    isTest?: boolean;
-    integrationKey?: string;
-    integrationId?: string;
-    includeArchived?: boolean;
-}
-declare class CreateConnectionRequest {
-    name: string;
-    integrationId: string;
-    credentials?: string;
-}
-declare class UpdateConnectionRequest {
-    name?: string;
-    credentials?: string;
-    accessToken?: string;
-}
-interface ConnectionSelector {
-    id?: string;
-    integrationKey?: string;
-    integrationId?: string;
-    connectionId?: string;
-}
-
-interface DataRecord {
-    id: string;
-    name?: string;
-    uri?: string;
-    iconUri?: string;
-    fields?: Record<string, any>;
-    udm?: string;
-    unifiedFields?: Record<string, any>;
-    rawFields?: Record<string, any>;
-    createdTime?: string;
-    updatedTime?: string;
-    deletedTime?: string;
-    createdById?: string;
-    updatedById?: string;
-}
-declare enum DataCollectionEventType {
-    CREATED = "created",
-    UPDATED = "updated",
-    DELETED = "deleted"
+declare class IntegrationLevelElementAccessor<Element, UpdateElementData> {
+    protected client: IntegrationAppApiClient;
+    protected integrationSelector: string;
+    protected elementSelector: string;
+    protected elementKey: string;
+    protected endpoint: string;
+    constructor(client: IntegrationAppApiClient, integrationSelector: string, elementSelector: string, elementKey: string);
+    getUniqueIdentifier(): string;
+    get(): Promise<Element>;
+    patch(data: Partial<UpdateElementData>): Promise<Element>;
+    put(data: UpdateElementData): Promise<Element>;
+    archive(): Promise<void>;
+    reset(): Promise<Element>;
 }
-
-interface DataSchema {
-    title?: string;
-    description?: string;
-    type?: string | string[];
-    format?: string;
-    properties?: {
-        [key: string]: DataSchema;
-    };
-    items?: DataSchema;
-    additionalProperties?: boolean | DataSchema;
-    enum?: string[];
-    referenceRecords?: DataRecord[];
-    referenceCollection?: {
-        key: any;
-        parameters?: Record<string, any>;
-    };
-    referenceUdm?: string;
-    default?: any;
-    allowCustom?: boolean;
-    $ref?: string;
-    required?: string[];
-    minLength?: number;
-    maxLength?: number;
-    minimum?: number;
-    maximum?: number;
-    maxItems?: number;
-    readOnly?: boolean;
-    writeOnly?: boolean;
-    examples?: any[];
-    anyOf?: DataSchema[];
-    isImplied?: boolean;
-    isSensitive?: boolean;
-    referenceCollectionPath?: string;
-    referenceCollectionUri?: string;
+declare class IntegrationLevelElementsListAccessor<Element, Query, CreateElementData> {
+    protected client: IntegrationAppApiClient;
+    protected integrationSelector: string;
+    protected elementKey: string;
+    protected endpoint: string;
+    constructor(client: IntegrationAppApiClient, integrationSelector: string, elementKey: string);
+    list(query?: Query): Promise<PaginationResponse<Element>>;
+    create(data: CreateElementData): Promise<Element>;
 }
 
 declare enum HttpRequestMethod {
@@ -382,680 +321,1520 @@ interface RestApiMapping {
     responseMapping?: any;
 }
 
-declare enum ConnectorMethodImplementationType {
-    mapping = "mapping",
-    operationMapping = "operation-mapping",
-    restApiMapping = "rest-api-mapping",
-    graphqlApiMapping = "graphql-api-mapping",
-    javascript = "javascript",
-    notSupported = "not-supported"
-}
-type ConnectorMethodImplementation = ConnectorMethodImplementationBase | ConnectorMethodImplementationMapping | ConnectorMethodImplementationOperationMapping | ConnectorMethodImplementationRestApiMapping | ConnectorMethodImplementationGraphqlApiMapping | ConnectorMethodImplementationJavascript | ConnectorMethodImplementationNotSupported;
-interface ConnectorMethodImplementationBase {
-    implementationType?: ConnectorMethodImplementationType;
-    filePath?: string;
-    inheritedFromPath?: string[];
-    isIncomplete?: boolean;
-    parametersSchema?: DataSchema;
-}
-interface ConnectorMethodImplementationMapping extends ConnectorMethodImplementationBase {
-    implementationType: ConnectorMethodImplementationType.mapping;
-    mapping: any;
-}
-interface ConnectorMethodImplementationOperationMapping extends ConnectorMethodImplementationBase {
-    implementationType: ConnectorMethodImplementationType.operationMapping;
-    mapping: OperationMapping;
-}
-interface ConnectorMethodImplementationRestApiMapping extends ConnectorMethodImplementationBase {
-    implementationType: ConnectorMethodImplementationType.restApiMapping;
-    mapping: RestApiMapping;
-}
-interface ConnectorMethodImplementationGraphqlApiMapping extends ConnectorMethodImplementationBase {
-    implementationType: ConnectorMethodImplementationType.graphqlApiMapping;
-    mapping: GraphQLApiMapping;
-}
-interface ConnectorMethodImplementationJavascript extends ConnectorMethodImplementationBase {
-    implementationType: ConnectorMethodImplementationType.javascript;
-    code: string;
-}
-interface ConnectorMethodImplementationNotSupported extends ConnectorMethodImplementationBase {
-    implementationType: ConnectorMethodImplementationType.notSupported;
-}
-
-type DataLocationSpec = DataCollectionSpec | DataDirectorySpec;
-declare enum DataLocationType {
-    directory = "directory",
-    collection = "collection"
-}
-interface DataLocationListItem {
-    key: string;
-    name: string;
-    type: DataLocationType;
-    isHidden?: boolean;
-}
-interface DataLocationPointer {
-    key: string;
-    parameters?: Record<string, any>;
-    type?: DataLocationType;
-}
-interface DataLocation {
-    key?: string;
-    parameters?: any;
-    path?: string;
-    name?: string;
-    type?: DataLocationType;
-    isDefault?: boolean;
-    read?: boolean;
-    write?: boolean;
-}
-interface DataLocationSpecBase {
-    type: DataLocationType;
-    key?: string;
-    name: string;
-    parametersSchema?: DataSchema;
-}
-interface DataCollectionSpec extends DataLocationSpecBase {
-    fieldsSchema?: DataSchema;
-    list?: DataCollectionListSpec;
-    search?: DataCollectionSearchSpec;
-    match?: DataCollectionMatchSpec;
-    findById?: DataCollectionFindByIdSpec;
-    create?: DataCollectionCreateSpec;
-    update?: DataCollectionUpdateSpec;
-    delete?: DataCollectionDeleteSpec;
-    events?: DataCollectionEventsSpec;
-    customFields?: boolean;
-    udm?: DataCollectionUdmsSpec;
-    find?: DataCollectionFindSpec;
-}
-interface ApiRequestSpec {
-    path: any;
-    method: any;
-}
-interface DataDirectorySpec extends DataLocationSpecBase {
-    locations?: DataLocation[];
-}
-interface DataCollectionMethodSpec {
-    apiRequests?: ApiRequestSpec[];
-}
-interface DataCollectionFindSpec extends DataCollectionMethodSpec {
-    queryFields?: string[];
-}
-interface DataCollectionMatchSpec extends DataCollectionMethodSpec {
-    fields?: string[];
-}
-interface DataCollectionListSpec extends DataCollectionMethodSpec {
-    filterFields?: string[];
-}
-interface DataCollectionSearchSpec extends DataCollectionMethodSpec {
-}
-interface DataCollectionFindByIdSpec extends DataCollectionMethodSpec {
-}
-interface DataCollectionCreateSpec extends DataCollectionMethodSpec {
-    fields?: string[];
-    requiredFields?: string[];
-    excludedFields?: string[];
-}
-interface DataCollectionUpdateSpec extends DataCollectionMethodSpec {
-    fields?: string[];
-    excludedFields?: string[];
-}
-interface DataCollectionDeleteSpec extends DataCollectionMethodSpec {
-}
-type DataCollectionUdmSpec = {
-    fields?: string[];
-    extract?: Record<string, any>;
-    parse?: Record<string, any>;
-};
-type DataCollectionUdmsSpec = Record<string, DataCollectionUdmSpec>;
-type DataCollectionEventTypeSpec = {
-    type: 'push' | 'pull';
-    isFullScan?: boolean;
-    isIdOnly?: boolean;
-};
-type DataCollectionEventsSpec = {
-    [value in DataCollectionEventType]: DataCollectionEventTypeSpec;
-} & {
-    all?: DataCollectionEventTypeSpec;
-};
-interface DataCollectionMethodRequest {
-    parameters?: Record<string, any>;
-}
-interface DataCollectionFindRequest {
-    query?: any;
-    cursor?: string;
-}
-interface DataCollectionFindResponse {
-    records: DataRecord[];
-    cursor?: string;
-}
-interface DataCollectionListRequest extends DataCollectionMethodRequest {
-    filter?: any;
-    unifiedFilter?: any;
-    cursor?: string;
-}
-interface DataCollectionListResponseDrilldown {
-    parameters?: Record<string, any>;
-    filter?: Record<string, any>;
-}
-interface DataCollectionListResponse {
-    records: DataRecord[];
-    drilldowns?: Array<DataCollectionListResponseDrilldown>;
-    cursor?: string;
-}
-interface DataCollectionSearchRequest extends DataCollectionMethodRequest {
-    query: string;
-    cursor?: string;
-}
-interface DataCollectionSearchResponse {
-    records: DataRecord[];
-    cursor?: string;
-}
-interface DataCollectionFindByIdRequest extends DataCollectionMethodRequest {
-    id: string;
-    udm?: string;
-}
-interface DataCollectionFindByIdResponse {
-    record: DataRecord;
-}
-interface DataCollectionMatchRequest extends DataCollectionMethodRequest {
-    query: Record<string, any>;
-}
-interface DataCollectionMatchResponse {
-    record?: DataRecord;
-}
-interface DataCollectionCreateRequest extends DataCollectionMethodRequest {
-    fields: Record<string, any>;
-}
-interface DataCollectionCreateResponse {
-    id: string;
-}
-interface DataCollectionUpdateRequest extends DataCollectionMethodRequest {
-    id: string;
-    fields: Record<string, any>;
-}
-interface DataCollectionUpdateResponse {
+declare const DataRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    uri: z.ZodOptional<z.ZodString>;
+    iconUri: z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    udm: z.ZodOptional<z.ZodString>;
+    unifiedFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    rawFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    createdTime: z.ZodOptional<z.ZodString>;
+    updatedTime: z.ZodOptional<z.ZodString>;
+    deletedTime: z.ZodOptional<z.ZodString>;
+    createdById: z.ZodOptional<z.ZodString>;
+    updatedById: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
     id: string;
-}
-interface DataCollectionDeleteRequest extends DataCollectionMethodRequest {
+    name?: string | undefined;
+    uri?: string | undefined;
+    iconUri?: string | undefined;
+    fields?: Record<string, any> | undefined;
+    udm?: string | undefined;
+    unifiedFields?: Record<string, any> | undefined;
+    rawFields?: Record<string, any> | undefined;
+    createdTime?: string | undefined;
+    updatedTime?: string | undefined;
+    deletedTime?: string | undefined;
+    createdById?: string | undefined;
+    updatedById?: string | undefined;
+}, {
     id: string;
-}
-interface DataCollectionDeleteResponse {
-}
-interface DataDirectoryListRequest {
-    cursor?: string;
-}
-interface DataDirectoryListResponse {
-    locations: DataLocation[];
-    cursor?: string;
-}
-
-declare enum UDM {
-    ACTIVITIES = "activities",
-    BILLS = "bills",
-    CAMPAIGN_MEMBERS = "campaign-members",
-    CAMPAIGNS = "campaigns",
-    COMPANIES = "companies",
-    CONTACTS = "contacts",
-    CONTACT_LISTS = "contact-lists",
-    CREDIT_NOTES = "credit-notes",
-    CUSTOMERS = "customers",
-    DEAL_PRODUCTS = "deal-products",
-    DEALS = "deals",
-    DEAL_STAGES = "deal-stages",
-    DOCUMENTS = "documents",
-    DRIVES = "drives",
-    DRIVE_ITEMS = "drive-items",
-    EEOCS = "eeocs",
-    EMAILS = "emails",
-    EMPLOYEES = "employees",
-    FILES = "files",
-    FOLDERS = "folders",
-    INVOICES = "invoices",
-    JOB_APPLICATIONS = "job-applications",
-    JOB_CANDIDATES = "job-candidates",
-    JOB_INTERVIEWS = "job-interviews",
-    JOB_OFFERS = "job-offers",
-    JOBS = "jobs",
-    JOURNAL_ENTRIES = "journal-entries",
-    LEADS = "leads",
-    LEDGER_ACCOUNTS = "ledger-accounts",
-    MEETINGS = "meetings",
-    MESSAGES = "messages",
-    NOTES = "notes",
-    ORDERS = "orders",
-    PAYMENTS = "payments",
-    PAYROLLS = "payrolls",
-    PRODUCTS = "products",
-    PROJECTS = "projects",
-    SUPPLIERS = "suppliers",
-    TASKS = "tasks",
-    TAX_RATES = "tax-rates",
-    USERS = "users",
-    TIMEOFF_BALANCES = "timeoff-balances",
-    TIMEOFF_REQUESTS = "timeoff-requests"
-}
-
-interface ConnectorUdmSpec {
-    defaultCollection?: DataLocationPointer;
-    rootDirectory?: DataLocationPointer;
-    collectionMappings: ConnectorUdmCollectionMapping[];
-}
-interface ConnectorUdmCollectionMapping extends DataLocationPointer {
-    fieldsToCollection?: any;
-    fieldsFromCollection?: any;
-}
-
-interface ConnectorUiSpec {
-    schema?: DataSchema;
-    description?: string;
-    helpUri?: string;
-    test?: boolean;
-}
-type ConnectorDataUdmSpec = {
-    rootLocation: DataLocation;
-};
-type ConnectorDataSpec = {
-    rootLocation?: DataLocation;
-    locations?: DataLocationSpec[];
-    udm?: Partial<Record<UDM, ConnectorDataUdmSpec>>;
-    root?: DataLocation;
-} & Partial<Record<UDM, DataLocation>>;
-type ConnectorApiType = 'openapi' | 'graphql';
-interface ConnectorSpec {
-    key?: string;
-    name?: string;
-    appUri?: string;
-    logoUri?: string;
-    apiDocsUri?: string;
-    api?: {
-        type: ConnectorApiType;
-    };
-    ui?: ConnectorUiSpec;
-    auth?: ConnectorAuth;
-    parametersSchema?: DataSchema;
-    data?: ConnectorDataSpec;
-    udms?: string[];
-    udm?: Record<string, ConnectorUdmSpec>;
-    operations?: ConnectorOperationHandler[];
-    test?: ConnectorMethodImplementation;
-    hasReadme?: boolean;
-    appUuid?: string;
-    knowledgeBaseUuid?: string;
-    workspaceId?: string;
-}
-type MinimalConnector = {
-    id: string;
-    key: string;
+    name?: string | undefined;
+    uri?: string | undefined;
+    iconUri?: string | undefined;
+    fields?: Record<string, any> | undefined;
+    udm?: string | undefined;
+    unifiedFields?: Record<string, any> | undefined;
+    rawFields?: Record<string, any> | undefined;
+    createdTime?: string | undefined;
+    updatedTime?: string | undefined;
+    deletedTime?: string | undefined;
+    createdById?: string | undefined;
+    updatedById?: string | undefined;
+}>;
+type DataRecord = z.infer<typeof DataRecordSchema>;
+
+declare const DataCollectionSpecSchema: z.ZodObject<{
+    type: z.ZodLiteral<"collection">;
+    key: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    parametersSchema: z.ZodOptional<z.ZodLazy<any>>;
+    fieldsSchema: z.ZodOptional<z.ZodLazy<any>>;
+    list: z.ZodOptional<z.ZodObject<{
+        apiRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodUnknown;
+            method: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            method?: unknown;
+            path?: unknown;
+        }, {
+            method?: unknown;
+            path?: unknown;
+        }>, "many">>;
+    } & {
+        filterFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+        filterFields?: string[] | undefined;
+    }, {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+        filterFields?: string[] | undefined;
+    }>>;
+    search: z.ZodOptional<z.ZodObject<{
+        apiRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodUnknown;
+            method: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            method?: unknown;
+            path?: unknown;
+        }, {
+            method?: unknown;
+            path?: unknown;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+    }, {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+    }>>;
+    match: z.ZodOptional<z.ZodObject<{
+        apiRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodUnknown;
+            method: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            method?: unknown;
+            path?: unknown;
+        }, {
+            method?: unknown;
+            path?: unknown;
+        }>, "many">>;
+    } & {
+        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        fields?: string[] | undefined;
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+    }, {
+        fields?: string[] | undefined;
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+    }>>;
+    findById: z.ZodOptional<z.ZodObject<{
+        apiRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodUnknown;
+            method: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            method?: unknown;
+            path?: unknown;
+        }, {
+            method?: unknown;
+            path?: unknown;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+    }, {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+    }>>;
+    create: z.ZodOptional<z.ZodObject<{
+        apiRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodUnknown;
+            method: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            method?: unknown;
+            path?: unknown;
+        }, {
+            method?: unknown;
+            path?: unknown;
+        }>, "many">>;
+    } & {
+        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        requiredFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        excludedFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        fields?: string[] | undefined;
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+        requiredFields?: string[] | undefined;
+        excludedFields?: string[] | undefined;
+    }, {
+        fields?: string[] | undefined;
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+        requiredFields?: string[] | undefined;
+        excludedFields?: string[] | undefined;
+    }>>;
+    update: z.ZodOptional<z.ZodObject<{
+        apiRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodUnknown;
+            method: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            method?: unknown;
+            path?: unknown;
+        }, {
+            method?: unknown;
+            path?: unknown;
+        }>, "many">>;
+    } & {
+        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        excludedFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        fields?: string[] | undefined;
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+        excludedFields?: string[] | undefined;
+    }, {
+        fields?: string[] | undefined;
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+        excludedFields?: string[] | undefined;
+    }>>;
+    delete: z.ZodOptional<z.ZodObject<{
+        apiRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodUnknown;
+            method: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            method?: unknown;
+            path?: unknown;
+        }, {
+            method?: unknown;
+            path?: unknown;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+    }, {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+    }>>;
+    events: z.ZodOptional<z.ZodObject<{
+        created: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+        updated: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+        deleted: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+        all: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodObject<{
+        type: z.ZodEnum<["push", "pull"]>;
+        isFullScan: z.ZodOptional<z.ZodBoolean>;
+        isIdOnly: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: "push" | "pull";
+        isFullScan?: boolean | undefined;
+        isIdOnly?: boolean | undefined;
+    }, {
+        type: "push" | "pull";
+        isFullScan?: boolean | undefined;
+        isIdOnly?: boolean | undefined;
+    }>, z.objectOutputType<{
+        created: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+        updated: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+        deleted: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+        all: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+    }, z.ZodObject<{
+        type: z.ZodEnum<["push", "pull"]>;
+        isFullScan: z.ZodOptional<z.ZodBoolean>;
+        isIdOnly: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: "push" | "pull";
+        isFullScan?: boolean | undefined;
+        isIdOnly?: boolean | undefined;
+    }, {
+        type: "push" | "pull";
+        isFullScan?: boolean | undefined;
+        isIdOnly?: boolean | undefined;
+    }>, "strip">, z.objectInputType<{
+        created: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+        updated: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+        deleted: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+        all: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+    }, z.ZodObject<{
+        type: z.ZodEnum<["push", "pull"]>;
+        isFullScan: z.ZodOptional<z.ZodBoolean>;
+        isIdOnly: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: "push" | "pull";
+        isFullScan?: boolean | undefined;
+        isIdOnly?: boolean | undefined;
+    }, {
+        type: "push" | "pull";
+        isFullScan?: boolean | undefined;
+        isIdOnly?: boolean | undefined;
+    }>, "strip">>>;
+    customFields: z.ZodOptional<z.ZodBoolean>;
+    udm: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        fields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        extract: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        parse: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        fields?: string[] | undefined;
+        extract?: Record<string, any> | undefined;
+        parse?: Record<string, any> | undefined;
+    }, {
+        fields?: string[] | undefined;
+        extract?: Record<string, any> | undefined;
+        parse?: Record<string, any> | undefined;
+    }>>>;
+    find: z.ZodOptional<z.ZodObject<{
+        apiRequests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodUnknown;
+            method: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            method?: unknown;
+            path?: unknown;
+        }, {
+            method?: unknown;
+            path?: unknown;
+        }>, "many">>;
+    } & {
+        queryFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+        queryFields?: string[] | undefined;
+    }, {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+        queryFields?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "collection";
     name: string;
-    logoUri: string;
-};
-
-declare const CONNECTOR_AUTH_TYPES: readonly ["integration-app-token", "oauth2", "oauth1", "client-credentials", "proxy"];
-type ConnectorAuthType = (typeof CONNECTOR_AUTH_TYPES)[number];
-type ConnectorAuthSpec = {
-    title?: string;
-    description?: string;
-    type: ConnectorAuthType;
-    ui?: {
-        schema?: DataSchema;
-        helpUri?: string;
-    };
-};
-interface ConnectorAuthHandlerBase extends ConnectorAuthSpec {
-    title?: string;
-    type: ConnectorAuthType;
-    credentialsSchema?: DataSchema;
-    customCredentialsSchema?: DataSchema;
-    makeApiClient?: ConnectorMethodImplementationBase;
-    refreshCredentials?: ConnectorMethodImplementationBase;
-    test?: ConnectorMethodImplementationBase;
-    enabled?: any;
-}
-interface ConnectorAuthOAuth2 extends ConnectorAuthHandlerBase {
-    type: 'oauth2';
-    getOAuthConfig?: ConnectorMethodImplementation;
-    getTokenData?: ConnectorMethodImplementation;
-    getCredentialsFromAccessTokenResponse?: ConnectorMethodImplementation;
-    getCredentialsFromRefreshTokenResponse?: ConnectorMethodImplementation;
-    oAuthConfig?: ConnectorMethodImplementation;
-}
-interface ConnectorAuthOAuth1 extends ConnectorAuthHandlerBase {
-    type: 'oauth1';
-    getOAuthConfig?: ConnectorMethodImplementation;
-}
-interface ConnectorAuthClientCredentials extends ConnectorAuthHandlerBase {
-    type: 'client-credentials';
-    getCredentialsFromConnectionParameters?: ConnectorMethodImplementationBase;
-}
-interface ConnectorAuthProxy extends ConnectorAuthHandlerBase {
-    type: 'proxy';
-    proxyKey: string;
-}
-interface ConnectorAuthIntegrationAppToken extends ConnectorAuthHandlerBase {
-    type: 'integration-app-token';
-}
-type ConnectorAuth = (ConnectorAuthOAuth2 | ConnectorAuthOAuth1 | ConnectorAuthClientCredentials | ConnectorAuthIntegrationAppToken | ConnectorAuthProxy) & {
-    options?: {
-        [key: string]: ConnectorAuthOAuth2 | ConnectorAuthOAuth1 | ConnectorAuthClientCredentials | ConnectorAuthIntegrationAppToken | ConnectorAuthProxy;
-    };
-};
-
-interface OpenConfigurationOptions {
-    onClose?: () => void;
-    showPoweredBy?: boolean;
-}
-
-interface Integration extends WorkspaceElement {
-    state?: WorkspaceElementState;
-    errors?: ErrorData[];
-    logoUri: string;
-    connectorId?: string;
-    connectorVersion?: string;
-    authOptions?: IntegrationAuthOption[];
-    oAuthCallbackUri?: string;
-    parametersSchema?: DataSchema;
-    parameters?: any;
-    baseUri: string;
-    connection?: Connection;
-    archivedAt?: string;
-    spec?: ConnectorSpec;
-    hasMissingParameters?: boolean;
-    hasDocumentation?: boolean;
-    hasOperations?: boolean;
-    hasData?: boolean;
-    hasEvents?: boolean;
-    hasGlobalWebhooks?: boolean;
-    hasUdm?: boolean;
-    isTest?: boolean;
-    appUuid?: string;
-    isDeactivated?: boolean;
-    authType?: ConnectorAuthType;
-}
-type IntegrationAuthOption = ConnectorAuthSpec & {
-    key: string;
-};
-type AppliedToIntegrations<Element> = {
-    element: Element;
-    integration: Integration;
-}[];
-
-interface CreateIntegrationRequest {
-    name?: string;
-    key: string;
-    baseUri: string;
-    logoUri: string;
-}
-interface UpdateIntegrationRequest {
-    name?: string;
-    key?: string;
-    baseUri?: string;
-    logoUri?: string;
-}
-interface FindIntegrationsQuery extends PaginationQuery, SearchQuery {
-}
-interface OpenNewConnectionOptions extends OpenConfigurationOptions {
-    allowMultipleConnections?: boolean;
-    name?: string;
-    connectorParameters?: any;
-}
-
-type CreateCustomerRequest = {
-    name?: string;
-    internalId: string;
-    fields?: any;
-    credentials?: any;
-};
-type UpdateCustomerRequest = {
-    name?: string;
-    internalId?: string;
-    fields?: any;
-    credentials?: any;
-};
-type FindCustomersQuery = PaginationQuery & SearchQuery & {
-    isTest?: boolean;
-};
-type CustomerSelector = {
-    id: string;
-};
-
-declare class CustomersAccessor extends ElementListAccessor<Customer, FindCustomersQuery, CreateCustomerRequest> {
-    constructor(client: IntegrationAppApiClient);
-}
-declare class CustomerAccessor extends ElementAccessor<Customer, UpdateCustomerRequest, CustomerSelector> {
-    constructor(client: IntegrationAppApiClient, selector: CustomerSelector | string);
-}
-
-type Customer = {
-    id: string;
+    key?: string | undefined;
+    match?: {
+        fields?: string[] | undefined;
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+    } | undefined;
+    search?: {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+    } | undefined;
+    find?: {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+        queryFields?: string[] | undefined;
+    } | undefined;
+    delete?: {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+    } | undefined;
+    list?: {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+        filterFields?: string[] | undefined;
+    } | undefined;
+    udm?: Record<string, {
+        fields?: string[] | undefined;
+        extract?: Record<string, any> | undefined;
+        parse?: Record<string, any> | undefined;
+    }> | undefined;
+    events?: z.objectOutputType<{
+        created: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+        updated: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+        deleted: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+        all: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+    }, z.ZodObject<{
+        type: z.ZodEnum<["push", "pull"]>;
+        isFullScan: z.ZodOptional<z.ZodBoolean>;
+        isIdOnly: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: "push" | "pull";
+        isFullScan?: boolean | undefined;
+        isIdOnly?: boolean | undefined;
+    }, {
+        type: "push" | "pull";
+        isFullScan?: boolean | undefined;
+        isIdOnly?: boolean | undefined;
+    }>, "strip"> | undefined;
+    parametersSchema?: any;
+    fieldsSchema?: any;
+    findById?: {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+    } | undefined;
+    create?: {
+        fields?: string[] | undefined;
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+        requiredFields?: string[] | undefined;
+        excludedFields?: string[] | undefined;
+    } | undefined;
+    update?: {
+        fields?: string[] | undefined;
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+        excludedFields?: string[] | undefined;
+    } | undefined;
+    customFields?: boolean | undefined;
+}, {
+    type: "collection";
     name: string;
-    internalId: string;
-    fields?: Record<string, any>;
-    credentials?: any;
-    lastActiveAt?: string;
-    isTest?: boolean;
-    isBillable?: boolean;
-};
-type User = Customer;
-
-interface ListFlowsForIntegrationQuery extends CommonListElementsQuery {
-    universalFlowId?: string | 'null';
-}
-interface FindFlowsQuery extends ListFlowsForIntegrationQuery {
-    integrationId?: string | 'null';
-}
-interface CreateFlowNodeRequest {
-    type: string;
-    config?: any;
-    ui?: any;
-    links?: FlowNodeLink[];
+    key?: string | undefined;
+    match?: {
+        fields?: string[] | undefined;
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+    } | undefined;
+    search?: {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+    } | undefined;
+    find?: {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+        queryFields?: string[] | undefined;
+    } | undefined;
+    delete?: {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+    } | undefined;
+    list?: {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+        filterFields?: string[] | undefined;
+    } | undefined;
+    udm?: Record<string, {
+        fields?: string[] | undefined;
+        extract?: Record<string, any> | undefined;
+        parse?: Record<string, any> | undefined;
+    }> | undefined;
+    events?: z.objectInputType<{
+        created: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+        updated: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+        deleted: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+        all: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["push", "pull"]>;
+            isFullScan: z.ZodOptional<z.ZodBoolean>;
+            isIdOnly: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }, {
+            type: "push" | "pull";
+            isFullScan?: boolean | undefined;
+            isIdOnly?: boolean | undefined;
+        }>>;
+    }, z.ZodObject<{
+        type: z.ZodEnum<["push", "pull"]>;
+        isFullScan: z.ZodOptional<z.ZodBoolean>;
+        isIdOnly: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: "push" | "pull";
+        isFullScan?: boolean | undefined;
+        isIdOnly?: boolean | undefined;
+    }, {
+        type: "push" | "pull";
+        isFullScan?: boolean | undefined;
+        isIdOnly?: boolean | undefined;
+    }>, "strip"> | undefined;
+    parametersSchema?: any;
+    fieldsSchema?: any;
+    findById?: {
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+    } | undefined;
+    create?: {
+        fields?: string[] | undefined;
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+        requiredFields?: string[] | undefined;
+        excludedFields?: string[] | undefined;
+    } | undefined;
+    update?: {
+        fields?: string[] | undefined;
+        apiRequests?: {
+            method?: unknown;
+            path?: unknown;
+        }[] | undefined;
+        excludedFields?: string[] | undefined;
+    } | undefined;
+    customFields?: boolean | undefined;
+}>;
+type DataCollectionSpec = z.infer<typeof DataCollectionSpecSchema>;
+interface DataLocationPointer {
+    key: string;
+    parameters?: Record<string, any>;
 }
-interface CreateFlowRequest {
+interface DataCollectionListItem {
     key: string;
     name: string;
-    integrationId?: string;
-    nodes?: Record<string, CreateFlowNodeRequest>;
-    parametersSchema?: DataSchema;
-    autoCreateInstances?: boolean;
-}
-interface UpdateFlowRequest extends CreateFlowRequest {
-    archivedAt?: string;
-}
-interface FlowSelector extends IntegrationSpecificElementSelector {
-    autoCreate?: boolean;
+    type: 'collection';
+    isHidden?: boolean;
 }
-type ListFlowInstancesForConnectionQuery = CommonInstancesListQuery & {
-    flowId?: string;
-    flowKey?: string;
-    enabled?: boolean;
-};
-type FindFlowInstancesQuery = ListFlowInstancesForConnectionQuery & CommonIntegrationOrConnectionQuery;
-interface FlowInstanceSelector extends ConnectionSelector, ElementInstanceSelector {
-    flowId?: string;
-    flowKey?: string;
-    instanceKey?: string;
-    autoUpdate?: boolean;
+declare const DataCollectionFindRequestSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodAny>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    cursor?: string | undefined;
+    query?: any;
+}, {
+    cursor?: string | undefined;
+    query?: any;
+}>;
+declare const DataCollectionFindResponseSchema: z.ZodObject<{
+    records: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        uri: z.ZodOptional<z.ZodString>;
+        iconUri: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        udm: z.ZodOptional<z.ZodString>;
+        unifiedFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        rawFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        createdTime: z.ZodOptional<z.ZodString>;
+        updatedTime: z.ZodOptional<z.ZodString>;
+        deletedTime: z.ZodOptional<z.ZodString>;
+        createdById: z.ZodOptional<z.ZodString>;
+        updatedById: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    }, {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    }>, "many">;
+    cursor: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    records: {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    }[];
+    cursor?: string | undefined;
+}, {
+    records: {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    }[];
+    cursor?: string | undefined;
+}>;
+declare const DataCollectionListRequestSchema: z.ZodObject<{
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    filter: z.ZodOptional<z.ZodAny>;
+    unifiedFilter: z.ZodOptional<z.ZodAny>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    filter?: any;
+    cursor?: string | undefined;
+    parameters?: Record<string, any> | undefined;
+    unifiedFilter?: any;
+}, {
+    filter?: any;
+    cursor?: string | undefined;
+    parameters?: Record<string, any> | undefined;
+    unifiedFilter?: any;
+}>;
+declare const DataCollectionListResponseSchema: z.ZodObject<{
+    records: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        uri: z.ZodOptional<z.ZodString>;
+        iconUri: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        udm: z.ZodOptional<z.ZodString>;
+        unifiedFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        rawFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        createdTime: z.ZodOptional<z.ZodString>;
+        updatedTime: z.ZodOptional<z.ZodString>;
+        deletedTime: z.ZodOptional<z.ZodString>;
+        createdById: z.ZodOptional<z.ZodString>;
+        updatedById: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    }, {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    }>, "many">;
+    drilldowns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        filter?: Record<string, any> | undefined;
+        parameters?: Record<string, any> | undefined;
+    }, {
+        filter?: Record<string, any> | undefined;
+        parameters?: Record<string, any> | undefined;
+    }>, "many">>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    records: {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    }[];
+    cursor?: string | undefined;
+    drilldowns?: {
+        filter?: Record<string, any> | undefined;
+        parameters?: Record<string, any> | undefined;
+    }[] | undefined;
+}, {
+    records: {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    }[];
+    cursor?: string | undefined;
+    drilldowns?: {
+        filter?: Record<string, any> | undefined;
+        parameters?: Record<string, any> | undefined;
+    }[] | undefined;
+}>;
+declare const DataCollectionSearchRequestSchema: z.ZodObject<{
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    query: z.ZodString;
+    cursor: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    cursor?: string | undefined;
+    parameters?: Record<string, any> | undefined;
+}, {
+    query: string;
+    cursor?: string | undefined;
+    parameters?: Record<string, any> | undefined;
+}>;
+declare const DataCollectionSearchResponseSchema: z.ZodObject<{
+    records: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        uri: z.ZodOptional<z.ZodString>;
+        iconUri: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        udm: z.ZodOptional<z.ZodString>;
+        unifiedFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        rawFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        createdTime: z.ZodOptional<z.ZodString>;
+        updatedTime: z.ZodOptional<z.ZodString>;
+        deletedTime: z.ZodOptional<z.ZodString>;
+        createdById: z.ZodOptional<z.ZodString>;
+        updatedById: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    }, {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    }>, "many">;
+    cursor: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    records: {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    }[];
+    cursor?: string | undefined;
+}, {
+    records: {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    }[];
+    cursor?: string | undefined;
+}>;
+declare const DataCollectionFindByIdRequestSchema: z.ZodObject<{
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    id: z.ZodString;
+    udm: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    udm?: string | undefined;
+    parameters?: Record<string, any> | undefined;
+}, {
+    id: string;
+    udm?: string | undefined;
+    parameters?: Record<string, any> | undefined;
+}>;
+declare const DataCollectionFindByIdResponseSchema: z.ZodObject<{
+    record: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        uri: z.ZodOptional<z.ZodString>;
+        iconUri: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        udm: z.ZodOptional<z.ZodString>;
+        unifiedFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        rawFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        createdTime: z.ZodOptional<z.ZodString>;
+        updatedTime: z.ZodOptional<z.ZodString>;
+        deletedTime: z.ZodOptional<z.ZodString>;
+        createdById: z.ZodOptional<z.ZodString>;
+        updatedById: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    }, {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    record: {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    };
+}, {
+    record: {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    };
+}>;
+declare const DataCollectionMatchRequestSchema: z.ZodObject<{
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    query: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    query: Record<string, any>;
+    parameters?: Record<string, any> | undefined;
+}, {
+    query: Record<string, any>;
+    parameters?: Record<string, any> | undefined;
+}>;
+declare const DataCollectionMatchResponseSchema: z.ZodObject<{
+    record: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        uri: z.ZodOptional<z.ZodString>;
+        iconUri: z.ZodOptional<z.ZodString>;
+        fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        udm: z.ZodOptional<z.ZodString>;
+        unifiedFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        rawFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        createdTime: z.ZodOptional<z.ZodString>;
+        updatedTime: z.ZodOptional<z.ZodString>;
+        deletedTime: z.ZodOptional<z.ZodString>;
+        createdById: z.ZodOptional<z.ZodString>;
+        updatedById: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    }, {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    record?: {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    } | undefined;
+}, {
+    record?: {
+        id: string;
+        name?: string | undefined;
+        uri?: string | undefined;
+        iconUri?: string | undefined;
+        fields?: Record<string, any> | undefined;
+        udm?: string | undefined;
+        unifiedFields?: Record<string, any> | undefined;
+        rawFields?: Record<string, any> | undefined;
+        createdTime?: string | undefined;
+        updatedTime?: string | undefined;
+        deletedTime?: string | undefined;
+        createdById?: string | undefined;
+        updatedById?: string | undefined;
+    } | undefined;
+}>;
+declare const DataCollectionCreateRequestSchema: z.ZodObject<{
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    fields: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    fields: Record<string, any>;
+    parameters?: Record<string, any> | undefined;
+}, {
+    fields: Record<string, any>;
+    parameters?: Record<string, any> | undefined;
+}>;
+declare const DataCollectionCreateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+declare const DataCollectionUpdateRequestSchema: z.ZodObject<{
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    id: z.ZodString;
+    fields: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    fields: Record<string, any>;
+    parameters?: Record<string, any> | undefined;
+}, {
+    id: string;
+    fields: Record<string, any>;
+    parameters?: Record<string, any> | undefined;
+}>;
+declare const DataCollectionUpdateResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+declare const DataCollectionDeleteRequestSchema: z.ZodObject<{
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+} & {
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    parameters?: Record<string, any> | undefined;
+}, {
+    id: string;
+    parameters?: Record<string, any> | undefined;
+}>;
+declare const DataCollectionDeleteResponseSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+type DataCollectionFindRequest = z.infer<typeof DataCollectionFindRequestSchema>;
+type DataCollectionFindResponse = z.infer<typeof DataCollectionFindResponseSchema>;
+type DataCollectionListRequest = z.infer<typeof DataCollectionListRequestSchema>;
+type DataCollectionListResponse = z.infer<typeof DataCollectionListResponseSchema>;
+type DataCollectionSearchRequest = z.infer<typeof DataCollectionSearchRequestSchema>;
+type DataCollectionSearchResponse = z.infer<typeof DataCollectionSearchResponseSchema>;
+type DataCollectionFindByIdRequest = z.infer<typeof DataCollectionFindByIdRequestSchema>;
+type DataCollectionFindByIdResponse = z.infer<typeof DataCollectionFindByIdResponseSchema>;
+type DataCollectionMatchRequest = z.infer<typeof DataCollectionMatchRequestSchema>;
+type DataCollectionMatchResponse = z.infer<typeof DataCollectionMatchResponseSchema>;
+type DataCollectionCreateRequest = z.infer<typeof DataCollectionCreateRequestSchema>;
+type DataCollectionCreateResponse = z.infer<typeof DataCollectionCreateResponseSchema>;
+type DataCollectionUpdateRequest = z.infer<typeof DataCollectionUpdateRequestSchema>;
+type DataCollectionUpdateResponse = z.infer<typeof DataCollectionUpdateResponseSchema>;
+type DataCollectionDeleteRequest = z.infer<typeof DataCollectionDeleteRequestSchema>;
+type DataCollectionDeleteResponse = z.infer<typeof DataCollectionDeleteResponseSchema>;
+
+interface ConnectorUdmSpec {
+    defaultCollection?: DataLocationPointer;
+    rootDirectory?: DataLocationPointer;
+    collectionMappings: ConnectorUdmCollectionMapping[];
 }
-interface ResetFlowInstanceOptions {
-    name?: boolean;
-    nodes?: Record<string, boolean>;
-    allNodes?: boolean;
+interface ConnectorUdmCollectionMapping extends DataLocationPointer {
+    fieldsToCollection?: any;
+    fieldsFromCollection?: any;
 }
-interface RunFlowOptions {
-    nodeKey?: string;
-    input?: any;
-    returnImmediately?: boolean;
-    onUpdate?: (...args: any) => void;
+
+interface DataSchema {
+    title?: string;
+    description?: string;
+    type?: string | string[];
+    format?: string;
+    properties?: {
+        [key: string]: DataSchema;
+    };
+    items?: DataSchema;
+    additionalProperties?: boolean | DataSchema;
+    enum?: string[];
+    referenceRecords?: DataRecord[];
+    referenceCollection?: {
+        key: any;
+        parameters?: Record<string, any>;
+    };
+    referenceUdm?: string;
+    default?: any;
+    allowCustom?: boolean;
+    $ref?: string;
+    required?: string[];
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    maxItems?: number;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    examples?: any[];
+    anyOf?: DataSchema[];
+    isImplied?: boolean;
+    isSensitive?: boolean;
+    referenceCollectionPath?: string;
+    referenceCollectionUri?: string;
 }
 
-interface ListFieldMappingsForIntegrationQuery extends CommonListElementsQuery {
-    universalFieldMappingId?: string | 'null';
+declare enum ConnectorMethodImplementationType {
+    mapping = "mapping",
+    operationMapping = "operation-mapping",
+    restApiMapping = "rest-api-mapping",
+    graphqlApiMapping = "graphql-api-mapping",
+    javascript = "javascript",
+    notSupported = "not-supported"
 }
-interface FindFieldMappingsQuery extends ListFieldMappingsForIntegrationQuery {
-    integrationId?: string | 'null';
+type ConnectorMethodImplementation = ConnectorMethodImplementationBase | ConnectorMethodImplementationMapping | ConnectorMethodImplementationOperationMapping | ConnectorMethodImplementationRestApiMapping | ConnectorMethodImplementationGraphqlApiMapping | ConnectorMethodImplementationJavascript | ConnectorMethodImplementationNotSupported;
+interface ConnectorMethodImplementationBase {
+    implementationType?: ConnectorMethodImplementationType;
+    filePath?: string;
+    inheritedFromPath?: string[];
+    isIncomplete?: boolean;
+    parametersSchema?: DataSchema;
 }
-type ListFieldMappingInstancesForConnectionQuery = CommonInstancesListQuery & {
-    fieldMappingId?: string;
-    universalFieldMappingId?: string;
-    dataSourceInstanceId?: string;
-};
-type FindFieldMappingInstancesQuery = ListFieldMappingInstancesForConnectionQuery & CommonIntegrationOrConnectionQuery;
-interface UpdateFieldMappingRequest {
-    key?: string;
-    name?: string;
-    dataSourceKey?: string;
-    dataSourceId?: string;
-    appSchema?: DataSchema;
-    direction?: FieldMappingDirection;
-    defaultImportValue?: any;
-    exportValue?: any;
-    importValue?: any;
-    defaultExportValue?: any;
-    frozenImportFields?: any;
-    frozenExportFields?: any;
-    frozenUnifiedExportFields?: any;
-    archivedAt?: string;
+interface ConnectorMethodImplementationMapping extends ConnectorMethodImplementationBase {
+    implementationType: ConnectorMethodImplementationType.mapping;
+    mapping: any;
 }
-interface CreateFieldMappingRequest extends UpdateFieldMappingRequest {
-    key: string;
-    name: string;
-    integrationId?: string;
+interface ConnectorMethodImplementationOperationMapping extends ConnectorMethodImplementationBase {
+    implementationType: ConnectorMethodImplementationType.operationMapping;
+    mapping: OperationMapping;
 }
-interface CreateFieldMappingInstanceRequest {
-    connectionId: string;
-    fieldMappingId?: string;
-    instanceKey?: string;
-    importValue?: any;
-    exportValue?: any;
+interface ConnectorMethodImplementationRestApiMapping extends ConnectorMethodImplementationBase {
+    implementationType: ConnectorMethodImplementationType.restApiMapping;
+    mapping: RestApiMapping;
 }
-interface UpdateFieldMappingInstanceRequest {
-    importValue?: any;
-    exportValue?: any;
+interface ConnectorMethodImplementationGraphqlApiMapping extends ConnectorMethodImplementationBase {
+    implementationType: ConnectorMethodImplementationType.graphqlApiMapping;
+    mapping: GraphQLApiMapping;
 }
-interface FieldMappingInstanceSelector extends ConnectionSelector, FlowInstanceSelector, ElementInstanceSelector {
-    fieldMappingKey?: string;
-    fieldMappingId?: string;
-    instanceKey?: string;
-    nodeKey?: string;
+interface ConnectorMethodImplementationJavascript extends ConnectorMethodImplementationBase {
+    implementationType: ConnectorMethodImplementationType.javascript;
+    code: string;
 }
-interface FieldMappingSelector extends IntegrationSpecificElementSelector {
+interface ConnectorMethodImplementationNotSupported extends ConnectorMethodImplementationBase {
+    implementationType: ConnectorMethodImplementationType.notSupported;
 }
 
-type InstanceKeyQuery = {
-    instanceKey?: string;
+declare const CONNECTOR_AUTH_TYPES: readonly ["integration-app-token", "membrane-token", "oauth2", "oauth1", "client-credentials", "proxy"];
+type ConnectorAuthType = (typeof CONNECTOR_AUTH_TYPES)[number];
+type ConnectorAuthSpec = {
+    title?: string;
+    description?: string;
+    type: ConnectorAuthType;
+    ui?: {
+        schema?: DataSchema;
+        helpUri?: string;
+    };
 };
-
-declare class ConnectionLevelElementAccessor<Element, UpdateElement> {
-    protected client: IntegrationAppApiClient;
-    protected connectionSelector: string;
-    protected selector: string;
-    protected elementKey: string;
-    protected query: Record<string, any>;
-    protected endpoint: string;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string, selector: string, elementKey: string, query: Record<string, any>);
-    protected uri(path?: string, query?: {}): string;
-    getUniqueIdentifier(): string;
-    get(query?: {
-        autoCreate?: boolean;
-    }): Promise<Element>;
-    create(): Promise<Element>;
-    patch(data: Partial<UpdateElement>): Promise<Element>;
-    put(data: UpdateElement): Promise<Element>;
-    archive(): Promise<void>;
-    reset(): Promise<Element>;
-    setup(): Promise<Element>;
-}
-declare class ConnectionLevelElementsListAccessor<Element, Query> {
-    protected client: IntegrationAppApiClient;
-    protected connectionSelector: string;
-    protected elementKey: string;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string, elementKey: string);
-    list(query?: Query): Promise<PaginationResponse<Element[]>>;
-}
-
-declare class IntegrationLevelElementAccessor<Element, UpdateElementData> {
-    protected client: IntegrationAppApiClient;
-    protected integrationSelector: string;
-    protected elementSelector: string;
-    protected elementKey: string;
-    protected endpoint: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string, elementSelector: string, elementKey: string);
-    getUniqueIdentifier(): string;
-    get(): Promise<Element>;
-    patch(data: Partial<UpdateElementData>): Promise<Element>;
-    put(data: UpdateElementData): Promise<Element>;
-    archive(): Promise<void>;
-    reset(): Promise<Element>;
+interface ConnectorAuthHandlerBase extends ConnectorAuthSpec {
+    title?: string;
+    type: ConnectorAuthType;
+    credentialsSchema?: DataSchema;
+    customCredentialsSchema?: DataSchema;
+    makeApiClient?: ConnectorMethodImplementationBase;
+    refreshCredentials?: ConnectorMethodImplementationBase;
+    test?: ConnectorMethodImplementationBase;
+    enabled?: any;
 }
-declare class IntegrationLevelElementsListAccessor<Element, Query, CreateElementData> {
-    protected client: IntegrationAppApiClient;
-    protected integrationSelector: string;
-    protected elementKey: string;
-    protected endpoint: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string, elementKey: string);
-    list(query?: Query): Promise<PaginationResponse<Element>>;
-    create(data: CreateElementData): Promise<Element>;
+interface ConnectorAuthOAuth2 extends ConnectorAuthHandlerBase {
+    type: 'oauth2';
+    getOAuthConfig?: ConnectorMethodImplementation;
+    getTokenData?: ConnectorMethodImplementation;
+    getCredentialsFromAccessTokenResponse?: ConnectorMethodImplementation;
+    getCredentialsFromRefreshTokenResponse?: ConnectorMethodImplementation;
+    oAuthConfig?: ConnectorMethodImplementation;
 }
-
-interface OpenFieldMappingInstanceConfigurationOptions extends OpenConfigurationOptions {
+interface ConnectorAuthOAuth1 extends ConnectorAuthHandlerBase {
+    type: 'oauth1';
+    getOAuthConfig?: ConnectorMethodImplementation;
 }
-declare class FieldMappingsAccessor extends ElementListAccessor<FieldMapping, FindFieldMappingsQuery, CreateFieldMappingRequest> {
-    constructor(client: IntegrationAppApiClient);
+interface ConnectorAuthClientCredentials extends ConnectorAuthHandlerBase {
+    type: 'client-credentials';
+    getCredentialsFromConnectionParameters?: ConnectorMethodImplementationBase;
 }
-declare class FieldMappingAccessor extends ElementAccessor<FieldMapping, UpdateFieldMappingRequest, FieldMappingSelector> {
-    constructor(client: IntegrationAppApiClient, selector: string | FieldMappingSelector);
-    getAppSchema(): Promise<any>;
-    apply(integrationKeys: string[]): Promise<FieldMapping[]>;
-    setup(): Promise<any>;
-    reset(): Promise<any>;
+interface ConnectorAuthProxy extends ConnectorAuthHandlerBase {
+    type: 'proxy';
+    proxyKey: string;
 }
-declare class FieldMappingInstancesAccessor extends ElementInstanceListAccessor<FieldMappingInstance, FindFieldMappingInstancesQuery> {
-    constructor(client: IntegrationAppApiClient);
+interface ConnectorAuthIntegrationAppToken extends ConnectorAuthHandlerBase {
+    type: 'integration-app-token';
 }
-declare class FieldMappingInstanceAccessor extends ElementInstanceAccessor<FieldMappingInstance, FieldMappingInstanceSelector, CreateFieldMappingInstanceRequest, UpdateFieldMappingInstanceRequest> {
-    private client;
-    constructor(client: IntegrationAppApiClient, selector: string | FieldMappingInstanceSelector);
-    setup(): Promise<void>;
-    reset(): Promise<void>;
-    openConfiguration({ onClose }?: OpenFieldMappingInstanceConfigurationOptions): Promise<void>;
+interface ConnectorAuthMembraneToken extends ConnectorAuthHandlerBase {
+    type: 'membrane-token';
 }
-declare class IntegrationLevelFieldMappingAccessor extends IntegrationLevelElementAccessor<FieldMapping, UpdateFieldMappingRequest> {
-    client: IntegrationAppApiClient;
-    integrationSelector: string;
-    fieldMappingSelector: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string, fieldMappingSelector: string);
+type ConnectorAuth = (ConnectorAuthOAuth2 | ConnectorAuthOAuth1 | ConnectorAuthClientCredentials | ConnectorAuthIntegrationAppToken | ConnectorAuthMembraneToken | ConnectorAuthProxy) & {
+    options?: {
+        [key: string]: ConnectorAuthOAuth2 | ConnectorAuthOAuth1 | ConnectorAuthClientCredentials | ConnectorAuthIntegrationAppToken | ConnectorAuthMembraneToken | ConnectorAuthProxy;
+    };
+};
+
+interface ConnectorUiSpec {
+    schema?: DataSchema;
+    description?: string;
+    helpUri?: string;
+    test?: boolean;
 }
-declare class IntegrationLevelFieldMappingsListAccessor extends IntegrationLevelElementsListAccessor<FieldMapping, ListFieldMappingsForIntegrationQuery, Omit<CreateFieldMappingRequest, 'integrationId'>> {
-    client: IntegrationAppApiClient;
-    integrationSelector: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string);
+type ConnectorApiType = 'openapi' | 'graphql';
+interface ConnectorSpec {
+    key?: string;
+    name?: string;
+    appUri?: string;
+    logoUri?: string;
+    apiDocsUri?: string;
+    api?: {
+        type: ConnectorApiType;
+    };
+    ui?: ConnectorUiSpec;
+    auth?: ConnectorAuth;
+    parametersSchema?: DataSchema;
+    udms?: string[];
+    udm?: Record<string, ConnectorUdmSpec>;
+    operations?: ConnectorOperationHandler[];
+    test?: ConnectorMethodImplementation;
+    hasReadme?: boolean;
+    appUuid?: string;
+    knowledgeBaseUuid?: string;
+    workspaceId?: string;
+    data?: any;
 }
-declare class ConnectionLevelFieldMappingAccessor extends ConnectionLevelElementAccessor<FieldMappingInstance, UpdateFieldMappingInstanceRequest> {
-    client: IntegrationAppApiClient;
-    connectionSelector: string;
-    fieldMappingSelector: string;
-    query: InstanceKeyQuery;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string, fieldMappingSelector: string, query: InstanceKeyQuery);
-    openConfiguration({ onClose }?: OpenFieldMappingInstanceConfigurationOptions): Promise<void>;
+type MinimalConnector = {
+    id: string;
+    key: string;
+    name: string;
+    logoUri: string;
+};
+
+interface BaseConnection extends BaseWorkspaceElement {
+    name: string;
+    userId: string;
+    disconnected?: boolean;
+    error?: ErrorData;
+    integrationId: string;
+    credentials?: unknown;
+    parameters?: unknown;
+    connectorParameters?: unknown;
+    accessToken?: string;
+    refreshToken?: string;
+    createdAt: string;
+    updatedAt: string;
+    lastActiveAt?: string;
+    nextCredentialsRefreshAt?: string;
+    archivedAt?: string;
+    state?: WorkspaceElementState;
+    errors?: ErrorData[];
 }
-declare class ConnectionLevelFieldMappingsAccessor extends ConnectionLevelElementsListAccessor<FieldMapping, ListFieldMappingInstancesForConnectionQuery> {
-    client: IntegrationAppApiClient;
-    connectionSelector: string;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string);
+interface ConnectionSpec extends ConnectorSpec {
+}
+declare class ConnectionSpec {
+    constructor(opts: ConnectionSpec);
 }
 
+type BaseCustomer = {
+    id: string;
+    name: string;
+    internalId: string;
+    fields?: Record<string, any>;
+    credentials?: any;
+    lastActiveAt?: string;
+    isTest?: boolean;
+    isBillable?: boolean;
+};
+
 declare enum FieldMappingDirection {
     IMPORT = "import",
     EXPORT = "export",
     BOTH = "both"
 }
-interface FieldMapping extends WorkspaceElement {
+interface BaseFieldMapping extends BaseMembraneInterface {
     revision: string;
     publishedRevision?: string;
     universalFieldMappingId?: string;
     universalFieldMappingRevision?: string;
     integrationId?: string;
-    integration?: Integration;
     dataSourceId: string;
     dataSourceKey: string;
     appSchema: DataSchema;
@@ -1069,185 +1848,228 @@ interface FieldMapping extends WorkspaceElement {
     frozenUnifiedExportFields?: any;
     archivedAt?: string;
     customized?: boolean;
-    appliedToIntegrations?: AppliedToIntegrations<FieldMapping>;
 }
-interface FieldMappingInstance extends WorkspaceElement {
+
+declare enum ActionType {
+    ListDataRecords = "list-data-records",
+    FindDataRecordById = "find-data-record-by-id",
+    MatchDataRecord = "match-data-record",
+    CreateDataRecord = "create-data-record",
+    FindOrCreateDataRecord = "find-or-create-data-record",
+    UpdateDataRecord = "update-data-record",
+    DeleteDataRecord = "delete-data-record",
+    SearchDataRecords = "search-data-record",
+    ConnectorOperation = "connector-operation",
+    ApiRequestToExternalApp = "api-request-to-external-app",
+    ApiRequestToYourApp = "api-request-to-your-app",
+    HttpRequest = "http-request",
+    RunJavascript = "run-javascript",
+    ApiRequest = "api-request"
+}
+
+interface BaseAction {
+    id: string;
+    key: string;
+    name: string;
+    revision: string;
+    integrationId?: string;
+    parentId?: string;
+    parentRevision?: string;
+    isCustomized?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+    archivedAt?: string;
+    type: ActionType;
+    inputSchema?: DataSchema;
+    config?: any;
+    outputMapping?: any;
+    customOutputSchema?: DataSchema;
+    defaultOutputSchema?: DataSchema;
+    transformedOutputSchema?: DataSchema;
+    outputSchema?: DataSchema;
+    dependencies?: WorkspaceElementDependency[];
+}
+
+interface DataSourceUnitConfig {
+    key?: string;
+    collectionKey?: any;
+    collectionParameters?: any;
+    udm?: any;
+    path?: string;
+    pullUpdatesIntervalSeconds?: number;
+    fullSyncIntervalSeconds?: number;
+}
+interface BaseDataSource extends BaseMembraneInterface {
+    revision: string;
+    publishedRevision?: string;
+    integrationId?: string;
+    universalDataSourceId?: string;
+    universalDataSourceRevision?: string;
+    udm?: string;
+    pullUpdatesIntervalSeconds?: number;
+    fullSyncIntervalSeconds?: number;
+    collectionKey?: string;
+    collectionParameters?: any;
+    archivedAt?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    customized?: boolean;
+    defaultPath?: string;
+}
+
+interface BaseDataSourceInstance extends BaseMembraneInterface {
     userId: string;
     revision: string;
-    user?: User;
+    dataSourceRevision?: string;
+    dataSourceId?: string;
+    universalDataSourceId?: string;
+    udm?: string;
     connectionId: string;
-    connection?: Connection;
     integrationId: string;
-    integration?: Integration;
-    fieldMappingRevision?: string;
-    fieldMappingId?: string;
-    fieldMapping?: FieldMapping;
     instanceKey?: string;
-    dataSourceInstanceId?: string;
-    dataSourceInstance?: DataSourceInstance;
-    dataSourceSchema?: DataSchema;
-    direction?: FieldMappingDirection;
-    appSchema?: DataSchema;
-    importValue?: any;
-    exportValue?: any;
+    collectionKey?: string;
+    collectionParameters?: any;
+    defaultCollectionKey?: string;
+    defaultCollectionParameters?: any;
+    collectionSpec?: DataCollectionSpec;
     isCustomized?: boolean;
-    unifiedExportValue?: any;
-    unifiedImportValue?: any;
-    frozenImportFields?: string[];
-    frozenExportFields?: string[];
-    state?: WorkspaceElementState;
-    error?: ErrorData;
-    externalSchema?: any;
+    errors?: ErrorData[];
+    pullUpdatesIntervalSeconds?: number;
+    fullSyncIntervalSeconds?: number;
+    path?: string;
+    defaultPath?: string;
 }
 
-interface OpenIntegrationUIIntegrationConfigurationOptions extends OpenConfigurationOptions {
-}
-declare class IntegrationsAccessor extends ElementListAccessor<Integration, FindIntegrationsQuery, CreateIntegrationRequest> {
-    constructor(client: IntegrationAppApiClient);
+type CreateCustomerRequest = {
+    name?: string;
+    internalId: string;
+    fields?: any;
+    credentials?: any;
+};
+type UpdateCustomerRequest = {
+    name?: string;
+    internalId?: string;
+    fields?: any;
+    credentials?: any;
+};
+type FindCustomersQuery = PaginationQuery & SearchQuery & {
+    isTest?: boolean;
+};
+type CustomerSelector = {
+    id: string;
+};
+type Customer = BaseCustomer;
+
+interface OpenConfigurationOptions {
+    onClose?: () => void;
+    showPoweredBy?: boolean;
 }
-declare class IntegrationAccessor extends ElementAccessor<Integration, UpdateIntegrationRequest> {
-    private client;
-    private integrationSelector;
+
+interface CreateIntegrationRequest {
+    name?: string;
+    key: string;
     baseUri: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string);
-    get actions(): IntegrationLevelActionsListAccessor;
-    action(actionSelector: string): IntegrationLevelActionAccessor;
-    get flows(): IntegrationLevelFlowsListAccessor;
-    flow(flowSelector: string): IntegrationLevelFlowAccessor;
-    get dataSources(): IntegrationLevelDataSourcesListAccessor;
-    dataSource(dataSourceSelector: string): IntegrationLevelDataSourceAccessor;
-    get fieldMappings(): IntegrationLevelFieldMappingsListAccessor;
-    fieldMapping(fieldMappingSelector: string): IntegrationLevelFieldMappingAccessor;
-    setup(): Promise<Integration>;
-    getConnectorSpec(): Promise<ConnectionSpec>;
-    open({ onClose }?: OpenIntegrationUIIntegrationConfigurationOptions): Promise<void>;
-    openNewConnection({ allowMultipleConnections, name, connectorParameters, }?: OpenNewConnectionOptions): Promise<Connection>;
-    connect({ name, parameters, connectorParameters, authOptionKey, allowMultipleConnections, redirectUri, sameWindow, }?: {
-        name?: string;
-        parameters?: any;
-        connectorParameters?: any;
-        authOptionKey?: string;
-        allowMultipleConnections?: boolean;
-    } & ({
-        sameWindow: true;
-        redirectUri: string;
-    } | {
-        sameWindow?: false;
-        redirectUri?: never;
-    })): Promise<Connection | undefined>;
-    createConnection({ parameters, name }: {
-        parameters?: any;
-        name?: string;
-    }): Promise<Connection | undefined>;
-    disconnect(): Promise<void>;
-    getOperations(): Promise<OperationListItem[]>;
-    getOperation(key: string): Promise<OperationSpec>;
-    getDataCollections(): Promise<DataLocationListItem[]>;
-    getDataCollection(key: string): Promise<DataLocationSpec>;
-    getDataLocations(): Promise<DataLocationListItem[]>;
-    getDataLocation(key: string): Promise<DataLocationSpec>;
+    logoUri: string;
+}
+interface UpdateIntegrationRequest {
+    name?: string;
+    key?: string;
+    baseUri?: string;
+    logoUri?: string;
 }
-
-interface OpenFlowRunEditorOptions extends OpenConfigurationOptions {
+interface FindIntegrationsQuery extends PaginationQuery, SearchQuery {
 }
-declare class FlowRunsAccessor {
-    private readonly client;
-    constructor(client: IntegrationAppApiClient);
-    find(query: FindFlowRunsQuery): Promise<FindFlowRunsResponse>;
-    create(request: CreateFlowRunRequest): Promise<FlowRun>;
+interface OpenNewConnectionOptions extends OpenConfigurationOptions {
+    allowMultipleConnections?: boolean;
+    name?: string;
+    connectorParameters?: any;
 }
-declare class FlowRunAccessor {
-    private readonly client;
-    id: string;
-    private baseUri;
-    constructor(client: IntegrationAppApiClient, id: string);
-    get(): Promise<FlowRun>;
-    stop(): Promise<void>;
-    getOutput(): Promise<any>;
-    getNodeRuns(nodeKey: string, parameters?: {
-        cursor?: string;
-    }): Promise<any>;
-    getNodeRun(nodeKey: string, runId: string): Promise<any>;
-    getNodeOutputs(nodeKey: string, parameters?: {
-        cursor?: string;
-    }): Promise<any>;
-    getNodeOutput(nodeKey: string, outputId: string): Promise<any>;
-    repeat(): Promise<FlowRun>;
-    openEditor({ onClose }?: OpenFlowRunEditorOptions): Promise<void>;
-    embedEditor({ mountTargetSelector, onClose, }?: {
-        mountTargetSelector?: string;
-    } & OpenFlowRunEditorOptions): Promise<void>;
+interface Integration extends BaseIntegration {
+    connection?: BaseConnection;
+    spec?: ConnectorSpec;
 }
 
-declare enum FlowRunState {
-    QUEUED = "queued",
-    RUNNING = "running",
-    COMPLETED = "completed",
-    STOPPED = "stopped",
-    FAILED = "failed"
-}
-declare enum FlowRunNodeState {
-    RUNNING = "running",
-    COMPLETED = "completed",
-    STOPPED = "stopped",
-    FAILED = "failed"
+declare enum IntegrationElementType {
+    APP_DATA_SCHEMA = "app-data-schema",
+    APP_EVENT_TYPE = "app-event-type",
+    DATA_SOURCE = "data-source",
+    SCHEMA = "schema",
+    FIELD_MAPPING = "field-mapping",
+    FLOW = "flow",
+    INTEGRATION = "integration",
+    ACTION = "action",
+    DATA_LINK_TABLE = "data-link-table",
+    EXTERNAL_EVENT = "external-event"
 }
-declare enum FlowRunLaunchedByTrigger {
-    ApiTrigger = "api-trigger",
-    ScheduleTrigger = "schedule-trigger",
-    AppEventTrigger = "app-event-trigger",
-    DataSourceTrigger = "data-source-trigger",
-    ExternalEvent = "external-event"
+interface IntegrationElementInstance {
+    type: IntegrationElementType;
+    instanceId?: string;
+    data?: any;
 }
-interface FlowRun {
-    id: string;
+
+interface FlowNode {
+    type?: string;
+    version?: number;
     name?: string;
-    flowInstanceId: string;
-    flowInstance?: FlowInstance;
-    universalFlowId?: string;
-    connectionId?: string;
-    connection?: Connection;
-    integrationId?: string;
-    integration?: Integration;
-    startNodeKey: string;
-    userId: string;
-    user?: Customer;
-    input?: any;
-    state: FlowRunState;
-    startTime: string;
-    endTime?: string;
-    errors?: ErrorData[];
-    nodes?: Record<string, FlowRunNode>;
-    launchedBy?: FlowRunLaunchedBy;
-}
-interface FlowRunNode {
-    state: FlowRunNodeState;
-    runs?: number;
-    erroredRuns?: number;
-    outputs?: number;
+    description?: string;
+    config?: any;
+    concurrency?: number;
+    onError?: 'stop' | 'continue';
+    ui?: any;
+    inputSchema?: any;
+    outputSchema?: any;
+    outputExample?: any;
+    links?: FlowNodeLink[];
+    isCustomized?: boolean;
 }
-interface FlowRunLaunchedBy {
-    type: FlowRunLaunchedByTrigger;
-    ids?: string[];
+interface BaseFlow extends BaseMembraneInterface {
+    integrationId?: string;
+    universalFlowId?: string;
+    universalFlowRevision?: string;
+    parametersSchema?: DataSchema;
+    nodes?: Record<string, FlowNode>;
+    autoCreateInstances?: boolean;
+    archivedAt?: string;
+    revision: string;
+    customized?: boolean;
 }
-interface CreateFlowRunRequest {
-    flowInstanceId: string;
-    nodeKey?: string;
-    input?: any;
+interface FlowNodeLink {
+    key?: string;
+    filter?: any;
+    name?: string;
 }
-interface FindFlowRunsQuery extends PaginationQuery {
-    id?: string;
-    flowInstanceId?: string;
-    startNodeKey?: string;
+
+interface BaseFlowInstance extends BaseMembraneInterface {
+    userId: string;
+    connectionId?: string;
     flowId?: string;
     universalFlowId?: string;
-    userId?: string;
-    state?: FlowRunState;
-    integrationId?: string;
-    connectionId?: string;
-    startedAfter?: string;
+    integrationId: string;
+    instanceKey?: string;
+    parameters?: any;
+    parametersSchema?: DataSchema;
+    nodes?: Record<string, FlowInstanceNode>;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+    state?: WorkspaceElementState;
+    outdated?: boolean;
+    customized?: {
+        name?: boolean;
+        nodes?: boolean;
+    };
+    dependencies?: IntegrationElementInstance[];
 }
-interface FindFlowRunsResponse extends PaginationResponse<FlowRun> {
+declare enum FlowInstanceNodeState {
+    SETUP_FAILED = "SETUP_FAILED",
+    READY = "READY"
+}
+interface FlowInstanceNode extends FlowNode {
+    state?: FlowInstanceNodeState;
+    errors?: ErrorData[];
+    userConfig?: any;
+    testInput?: any;
+    dependencies?: IntegrationElementInstance[];
 }
 
 declare const createFlowInstanceSchema: z.ZodObject<{
@@ -1272,12 +2094,12 @@ declare const createFlowInstanceSchema: z.ZodObject<{
             name: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }, {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }>, "many">>;
         isCustomized: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
@@ -1290,8 +2112,8 @@ declare const createFlowInstanceSchema: z.ZodObject<{
         ui?: any;
         links?: {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }[] | undefined;
         isCustomized?: boolean | undefined;
     }, {
@@ -1304,8 +2126,8 @@ declare const createFlowInstanceSchema: z.ZodObject<{
         ui?: any;
         links?: {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }[] | undefined;
         isCustomized?: boolean | undefined;
     }>>>;
@@ -1322,11 +2144,11 @@ declare const createFlowInstanceSchema: z.ZodObject<{
     }>>;
 }, "strip", z.ZodTypeAny, {
     name?: string | undefined;
-    userId?: string | undefined;
-    integrationId?: string | undefined;
-    connectionId?: string | undefined;
     parameters?: any;
+    userId?: string | undefined;
     flowId?: string | undefined;
+    connectionId?: string | undefined;
+    integrationId?: string | undefined;
     instanceKey?: string | undefined;
     nodes?: Record<string, {
         concurrency?: number | undefined;
@@ -1338,8 +2160,8 @@ declare const createFlowInstanceSchema: z.ZodObject<{
         ui?: any;
         links?: {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }[] | undefined;
         isCustomized?: boolean | undefined;
     }> | undefined;
@@ -1350,11 +2172,11 @@ declare const createFlowInstanceSchema: z.ZodObject<{
     } | undefined;
 }, {
     name?: string | undefined;
-    userId?: string | undefined;
-    integrationId?: string | undefined;
-    connectionId?: string | undefined;
     parameters?: any;
+    userId?: string | undefined;
     flowId?: string | undefined;
+    connectionId?: string | undefined;
+    integrationId?: string | undefined;
     instanceKey?: string | undefined;
     nodes?: Record<string, {
         concurrency?: number | undefined;
@@ -1366,8 +2188,8 @@ declare const createFlowInstanceSchema: z.ZodObject<{
         ui?: any;
         links?: {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }[] | undefined;
         isCustomized?: boolean | undefined;
     }> | undefined;
@@ -1393,12 +2215,12 @@ declare const updateFlowInstanceSchema: z.ZodObject<{
             name: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }, {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }>, "many">>;
         concurrency: z.ZodOptional<z.ZodNumber>;
         isCustomized: z.ZodOptional<z.ZodBoolean>;
@@ -1411,8 +2233,8 @@ declare const updateFlowInstanceSchema: z.ZodObject<{
         onError?: "stop" | "continue" | undefined;
         links?: {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }[] | undefined;
         isCustomized?: boolean | undefined;
     }, {
@@ -1424,8 +2246,8 @@ declare const updateFlowInstanceSchema: z.ZodObject<{
         onError?: "stop" | "continue" | undefined;
         links?: {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }[] | undefined;
         isCustomized?: boolean | undefined;
     }>>>;
@@ -1452,8 +2274,8 @@ declare const updateFlowInstanceSchema: z.ZodObject<{
         onError?: "stop" | "continue" | undefined;
         links?: {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }[] | undefined;
         isCustomized?: boolean | undefined;
     }> | undefined;
@@ -1475,8 +2297,8 @@ declare const updateFlowInstanceSchema: z.ZodObject<{
         onError?: "stop" | "continue" | undefined;
         links?: {
             key?: string | undefined;
-            name?: string | undefined;
             filter?: any;
+            name?: string | undefined;
         }[] | undefined;
         isCustomized?: boolean | undefined;
     }> | undefined;
@@ -1490,33 +2312,391 @@ declare const updateFlowInstanceSchema: z.ZodObject<{
 type CreateFlowInstanceRequest = z.infer<typeof createFlowInstanceSchema>;
 type UpdateFlowInstanceRequest = z.infer<typeof updateFlowInstanceSchema>;
 
-declare enum IntegrationElementType {
-    APP_DATA_SCHEMA = "app-data-schema",
-    APP_EVENT_TYPE = "app-event-type",
-    DATA_SOURCE = "data-source",
-    SCHEMA = "schema",
-    FIELD_MAPPING = "field-mapping",
-    FLOW = "flow",
-    INTEGRATION = "integration",
-    ACTION = "action",
-    DATA_LINK_TABLE = "data-link-table",
-    EXTERNAL_EVENT = "external-event"
+declare enum FlowRunState {
+    QUEUED = "queued",
+    RUNNING = "running",
+    COMPLETED = "completed",
+    STOPPED = "stopped",
+    FAILED = "failed"
+}
+declare enum FlowRunLaunchedByTrigger {
+    ApiTrigger = "api-trigger",
+    ScheduleTrigger = "schedule-trigger",
+    AppEventTrigger = "app-event-trigger",
+    DataSourceTrigger = "data-source-trigger",
+    ExternalEvent = "external-event"
+}
+interface CreateFlowRunRequest {
+    flowInstanceId: string;
+    nodeKey?: string;
+    input?: any;
+}
+interface FindFlowRunsQuery extends PaginationQuery {
+    id?: string;
+    flowInstanceId?: string;
+    startNodeKey?: string;
+    flowId?: string;
+    universalFlowId?: string;
+    userId?: string;
+    state?: FlowRunState;
+    integrationId?: string;
+    connectionId?: string;
+    startedAfter?: string;
+}
+interface FlowRunLaunchedBy {
+    type: FlowRunLaunchedByTrigger;
+    ids?: string[];
+}
+interface FindFlowRunsResponse extends PaginationResponse<FlowRun> {
+}
+interface FlowRun extends BaseFlowRun {
+    flowInstance?: BaseFlowInstance;
+    connection?: BaseConnection;
+    integration?: BaseIntegration;
+    user?: BaseCustomer;
+}
+
+declare enum FlowRunNodeState {
+    RUNNING = "running",
+    COMPLETED = "completed",
+    STOPPED = "stopped",
+    FAILED = "failed"
+}
+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;
+}
+interface FlowRunNode {
+    state: FlowRunNodeState;
+    runs?: number;
+    erroredRuns?: number;
+    outputs?: number;
+}
+
+interface BaseAppDataSchema extends BaseMembraneInterface {
+    schema: any;
+    code?: string;
+    archivedAt?: string;
+    revision?: string;
 }
-interface ElementTemplateFields {
-    id: string;
+
+interface FindAppDataSchemasQuery extends PaginationQuery {
+}
+type CreateAppDataSchemaRequest = {
     key: string;
     name: string;
+    schema?: any;
+    code?: string;
+};
+type UpdateAppDataSchemaRequest = {
+    key?: string;
+    name?: string;
+    schema?: any;
+    code?: string;
+    archivedAt?: string;
+};
+
+interface BaseAppEventType extends BaseMembraneInterface {
     revision: string;
+    archivedAt?: string;
+    subscribeRequest?: HttpRequestSpec;
+    example?: any;
+    schema?: DataSchema;
+    globalWebhookUri: string;
+    userIdFormula?: any;
+}
+
+interface UpdateAppEventTypeRequest {
+    key?: string;
+    name?: string;
+    subscribeRequest?: HttpRequestSpec;
+    example?: any;
+    schema?: DataSchema;
+    userIdFormula?: any;
+}
+interface CreateAppEventTypeRequest extends UpdateAppEventTypeRequest {
+    key: string;
+    name: string;
+}
+interface FindAppEventTypesQuery extends PaginationQuery {
+    includeArchived?: boolean;
+}
+
+declare enum DataLinkDirection {
+    IMPORT = "import",
+    EXPORT = "export",
+    BOTH = "both"
+}
+interface BaseDataLinkTable extends BaseMembraneInterface {
+    archivedAt?: string;
+}
+
+interface FindDataLinkTablesQuery extends PaginationQuery {
+}
+type CreateDataLinkTableRequest = Omit<BaseDataLinkTable, 'id' | 'userId'>;
+type UpdateDataLinkTableRequest = CreateDataLinkTableRequest;
+
+interface DataSourceInstance extends BaseDataSourceInstance {
+    user?: BaseCustomer;
+    dataSource?: BaseDataSource;
+    connection?: BaseConnection;
+    integration?: BaseIntegration;
+}
+
+interface ListFlowsForIntegrationQuery extends CommonListElementsQuery {
+    universalFlowId?: string | 'null';
+}
+interface FindFlowsQuery extends ListFlowsForIntegrationQuery {
+    integrationId?: string | 'null';
+}
+interface CreateFlowNodeRequest {
+    type: string;
+    config?: any;
+    ui?: any;
+    links?: FlowNodeLink[];
+}
+interface CreateFlowRequest {
+    key: string;
+    name: string;
     integrationId?: string;
-    integration?: Integration;
-    parentId?: string;
-    parentRevision?: string;
-    isCustomized?: boolean;
-    createdAt?: string;
-    updatedAt?: string;
+    nodes?: Record<string, CreateFlowNodeRequest>;
+    parametersSchema?: DataSchema;
+    autoCreateInstances?: boolean;
+}
+interface UpdateFlowRequest extends CreateFlowRequest {
+    archivedAt?: string;
+}
+interface FlowSelector extends IntegrationSpecificElementSelector {
+    autoCreate?: boolean;
+}
+type ListFlowInstancesForConnectionQuery = CommonInstancesListQuery & {
+    flowId?: string;
+    flowKey?: string;
+    enabled?: boolean;
+};
+type FindFlowInstancesQuery = ListFlowInstancesForConnectionQuery & CommonIntegrationOrConnectionQuery;
+interface FlowInstanceSelector extends ConnectionSelector, ElementInstanceSelector {
+    flowId?: string;
+    flowKey?: string;
+    instanceKey?: string;
+    autoUpdate?: boolean;
+}
+interface ResetFlowInstanceOptions {
+    name?: boolean;
+    nodes?: Record<string, boolean>;
+    allNodes?: boolean;
+}
+interface RunFlowOptions {
+    nodeKey?: string;
+    input?: any;
+    returnImmediately?: boolean;
+    onUpdate?: (...args: any) => void;
+}
+interface Flow extends BaseFlow {
+    integration?: BaseIntegration;
+    appliedToIntegrations?: AppliedToIntegrations<Flow>;
+}
+interface FlowInstance extends BaseFlowInstance {
+    user?: BaseCustomer;
+    connection?: BaseConnection;
+    flow?: Flow;
+    integration?: BaseIntegration;
+}
+
+interface ListDataSourcesForIntegrationQuery extends PaginationQuery {
+    universalDataSourceId?: string | 'null';
+}
+interface FindDataSourcesQuery extends ListDataSourcesForIntegrationQuery {
+    integrationId?: string | 'null';
+}
+type CreateDataSourceRequest = {
+    key: string;
+    name: string;
+    integrationId?: string;
+    udm?: string;
+    pullUpdatesIntervalSeconds?: number;
+    fullSyncIntervalSeconds?: number;
+    rootPath?: string;
+    defaultPath?: string;
+    collectionKey?: string;
+    collectionParameters?: any;
+};
+type UpdateDataSourceRequest = {
+    key?: string;
+    name?: string;
+    archivedAt?: string;
+    udm?: string;
+    pullUpdatesIntervalSeconds?: number;
+    fullSyncIntervalSeconds?: number;
+    rootPath?: string;
+    defaultPath?: string;
+};
+interface DataSourceSelector extends IntegrationSpecificElementSelector {
+}
+interface DataSourceInstanceSelector extends ConnectionSelector, FlowInstanceSelector, ElementInstanceSelector {
+    dataSourceKey?: string;
+    dataSourceId?: string;
+    instanceKey?: string;
+    nodeKey?: string;
+    udm?: string;
+}
+interface FindDataSourceInstancesQuery extends PaginationQuery {
+    userId?: string;
+    dataSourceId?: string;
+    universalDataSourceId?: string;
+    connectionId?: string;
+    integrationKey?: string;
+    integrationId?: string;
+}
+interface CreateDataSourceInstanceRequest {
+    dataSourceId: string;
+    connectionId: string;
+    path?: string;
+}
+interface UpdateDataSourceInstanceRequest {
+    path?: string;
+    collectionKey?: string;
+    collectionParameters?: any;
+    pullUpdatesIntervalSeconds?: number;
+    fullSyncIntervalSeconds?: number;
+    subscribedTo?: {
+        created?: boolean;
+        updated?: boolean;
+        deleted?: boolean;
+    };
+}
+type ListDataSourceInstancesForConnectionQuery = PaginationQuery & {
+    dataSourceId?: string;
+};
+interface DataSource extends BaseDataSource {
+    integration?: BaseIntegration;
+    appliedToIntegrations?: AppliedToIntegrations<DataSource>;
+}
+
+interface ListFieldMappingsForIntegrationQuery extends CommonListElementsQuery {
+    universalFieldMappingId?: string | 'null';
+}
+interface FindFieldMappingsQuery extends ListFieldMappingsForIntegrationQuery {
+    integrationId?: string | 'null';
+}
+interface UpdateFieldMappingRequest {
+    key?: string;
+    name?: string;
+    dataSourceKey?: string;
+    dataSourceId?: string;
+    appSchema?: DataSchema;
+    direction?: FieldMappingDirection;
+    defaultImportValue?: any;
+    exportValue?: any;
+    importValue?: any;
+    defaultExportValue?: any;
+    frozenImportFields?: any;
+    frozenExportFields?: any;
+    frozenUnifiedExportFields?: any;
+    archivedAt?: string;
+}
+interface CreateFieldMappingRequest extends UpdateFieldMappingRequest {
+    key: string;
+    name: string;
+    integrationId?: string;
+}
+interface FieldMappingSelector extends IntegrationSpecificElementSelector {
+}
+interface FieldMapping extends BaseFieldMapping {
+    integration?: BaseIntegration;
+    appliedToIntegrations?: AppliedToIntegrations<FieldMapping>;
+}
+
+type ScenarioToDo = {
+    name: string;
+    description: string;
+    isComplete: boolean;
+};
+type ScenarioElement = {
+    id: string;
+    type: IntegrationElementType;
+    element?: any;
+};
+interface FindScenariosQuery extends SearchQuery, PaginationQuery {
+}
+interface CreateScenarioRequest {
+    name: string;
+    key: string;
+    elements?: ScenarioElement[];
+    todos?: ScenarioToDo[];
+}
+interface UpdateScenarioRequest {
+    name?: string;
+    key?: string;
+    elements?: ScenarioElement[];
+    todos?: ScenarioToDo[];
+}
+interface Scenario extends BaseScenario {
+    appliedToIntegrations?: BaseIntegration[];
+}
+
+interface BaseScenario extends BaseMembraneInterface {
+    appId: string;
+    scenarioTemplateId?: string;
+    elements?: ScenarioElement[];
+    connectors?: MinimalConnector[];
+    todos?: ScenarioToDo[];
     archivedAt?: string;
 }
-interface ElementInstanceFields {
+
+declare enum ScreenType {
+    Integration = "integration"
+}
+declare enum ScreenBlockType {
+    Flow = "flow",
+    FieldMapping = "field-mapping",
+    DataSource = "data-source",
+    Action = "action"
+}
+interface ScreenBlock {
+    type: ScreenBlockType;
+    [key: string]: any;
+}
+interface ScreenSelector {
+    id?: string;
+    type?: ScreenType;
+    key?: string;
+    autoCreate?: boolean;
+    connectionId?: string;
+}
+interface UpdateScreenRequest {
+    blocks?: ScreenBlock[];
+    key?: string;
+}
+interface CreateScreenRequest extends UpdateScreenRequest {
+    type: ScreenType;
+}
+interface FindScreensQuery extends PaginationQuery {
+    type?: ScreenType;
+}
+interface Screen extends BaseScreen {
+}
+
+interface BaseScreen extends BaseWorkspaceElement {
+    type: ScreenType;
+    key?: string;
+    blocks: ScreenBlock[];
+}
+
+interface BaseActionInstance {
     id: string;
     name: string;
     revision: string;
@@ -1524,479 +2704,306 @@ interface ElementInstanceFields {
     parentRevision?: string;
     universalParentId?: string;
     userId: string;
-    user?: Customer;
     instanceKey?: string;
-    isCustomized?: boolean;
-    connectionId: string;
-    connection?: Connection;
-    integrationId?: string;
-    integration?: Integration;
-    dependencies?: IntegrationElementInstance[];
-    errors?: ErrorData[];
     createdAt?: string;
     updatedAt?: string;
     archivedAt?: string;
-}
-interface IntegrationElementInstance {
-    type: IntegrationElementType;
-    instanceId?: string;
-    data?: any;
-}
-
-interface FlowNode {
-    type?: string;
-    version?: number;
-    name?: string;
-    description?: string;
-    config?: any;
-    concurrency?: number;
-    onError?: 'stop' | 'continue';
-    ui?: any;
+    type: ActionType;
     inputSchema?: any;
+    config?: any;
     outputSchema?: any;
-    outputExample?: any;
-    links?: FlowNodeLink[];
-    isCustomized?: boolean;
-}
-interface Flow extends WorkspaceElement {
-    integrationId?: string;
-    integration?: Integration;
-    universalFlowId?: string;
-    universalFlowRevision?: string;
-    parametersSchema?: DataSchema;
-    nodes?: Record<string, FlowNode>;
-    autoCreateInstances?: boolean;
-    archivedAt?: string;
-    revision: string;
-    customized?: boolean;
-    appliedToIntegrations?: AppliedToIntegrations<Flow>;
+    isOutdated?: boolean;
+    state: WorkspaceElementState;
 }
-interface FlowInstance extends WorkspaceElement {
+
+interface BaseFieldMappingInstance extends BaseMembraneInterface {
     userId: string;
-    user?: User;
-    connectionId?: string;
-    connection?: Connection;
-    flow?: Flow;
-    flowId?: string;
-    universalFlowId?: string;
+    revision: string;
+    connectionId: string;
     integrationId: string;
-    integration?: Integration;
+    fieldMappingRevision?: string;
+    fieldMappingId?: string;
     instanceKey?: string;
-    parameters?: any;
-    parametersSchema?: DataSchema;
-    nodes?: Record<string, FlowInstanceNode>;
-    enabled: boolean;
-    createdAt: string;
-    updatedAt: string;
+    dataSourceInstanceId?: string;
+    dataSourceSchema?: DataSchema;
+    direction?: FieldMappingDirection;
+    appSchema?: DataSchema;
+    importValue?: any;
+    exportValue?: any;
+    isCustomized?: boolean;
+    unifiedExportValue?: any;
+    unifiedImportValue?: any;
+    frozenImportFields?: string[];
+    frozenExportFields?: string[];
     state?: WorkspaceElementState;
-    outdated?: boolean;
-    customized?: {
-        name?: boolean;
-        nodes?: boolean;
-    };
-    dependencies?: IntegrationElementInstance[];
-}
-declare enum FlowInstanceNodeState {
-    SETUP_FAILED = "SETUP_FAILED",
-    READY = "READY"
-}
-interface FlowInstanceNode extends FlowNode {
-    state?: FlowInstanceNodeState;
-    errors?: ErrorData[];
-    userConfig?: any;
-    testInput?: any;
-    dependencies?: IntegrationElementInstance[];
-}
-interface FlowNodeLink {
-    key?: string;
-    filter?: any;
-    name?: string;
+    error?: ErrorData;
+    externalSchema?: any;
 }
 
-interface OpenFlowInstanceConfigurationOptions extends OpenConfigurationOptions {
-    nodeKey?: string;
-}
-interface OpenFlowInstanceEditorOptions extends OpenConfigurationOptions {
-}
-declare class FlowsAccessor extends ElementListAccessor<Flow, FindFlowsQuery, CreateFlowRequest> {
-    constructor(client: IntegrationAppApiClient);
-}
-declare class FlowAccessor extends ElementAccessor<Flow, UpdateFlowRequest, FlowSelector> {
-    constructor(client: IntegrationAppApiClient, selector: FlowSelector | string);
-    apply(integrationKeys: string[]): Promise<Flow[]>;
-    reset(): Promise<Flow>;
-}
-declare class FlowInstancesAccessor extends ElementInstanceListAccessor<FlowInstance, FindFlowInstancesQuery> {
-    constructor(client: IntegrationAppApiClient);
-    create(data: CreateFlowInstanceRequest): Promise<FlowInstance>;
-}
-declare class FlowInstanceAccessor extends ElementInstanceAccessor<FlowInstance, FlowInstanceSelector, CreateFlowInstanceRequest, UpdateFlowInstanceRequest> {
-    protected client: IntegrationAppApiClient;
-    protected selector: FlowInstanceSelector | string;
-    constructor(client: IntegrationAppApiClient, selector: FlowInstanceSelector | string);
-    enable(): Promise<FlowInstance>;
-    disable(): Promise<FlowInstance>;
-    updateToLatestFlow(): Promise<FlowInstance>;
-    setup(): Promise<FlowInstance>;
-    reset(options?: ResetFlowInstanceOptions): Promise<FlowInstance>;
-    openConfiguration({ nodeKey, onClose }?: OpenFlowInstanceConfigurationOptions): Promise<void>;
-    openEditor({ onClose }?: OpenFlowInstanceEditorOptions): Promise<void>;
-    embedEditor({ mountTargetSelector, onClose, }?: {
-        mountTargetSelector?: string;
-    } & OpenFlowInstanceEditorOptions): Promise<void>;
-    startRun(options?: RunFlowOptions): Promise<FlowRun>;
-    run(options?: RunFlowOptions): Promise<FlowRun>;
-}
-declare class IntegrationLevelFlowAccessor extends IntegrationLevelElementAccessor<Flow, UpdateFlowRequest> {
-    client: IntegrationAppApiClient;
-    integrationSelector: string;
-    flowSelector: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string, flowSelector: string);
-}
-declare class IntegrationLevelFlowsListAccessor extends IntegrationLevelElementsListAccessor<Flow, ListFlowsForIntegrationQuery, Omit<CreateFlowRequest, 'integrationId'>> {
-    client: IntegrationAppApiClient;
-    integrationSelector: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string);
+interface BaseDataLinkTableInstance extends BaseMembraneInterface {
+    dataLinkTableId?: string;
+    connectionId?: string;
+    integrationId: string;
+    instanceKey?: string;
+    userId: string;
+    archivedAt?: string;
 }
-declare class ConnectionLevelFlowAccessor extends ConnectionLevelElementAccessor<FlowInstance, UpdateFlowInstanceRequest> {
-    client: IntegrationAppApiClient;
-    connectionSelector: string;
-    flowSelector: string;
-    query: InstanceKeyQuery;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string, flowSelector: string, query: InstanceKeyQuery);
-    enable(): Promise<FlowInstance>;
-    disable(): Promise<FlowInstance>;
-    run(options: {
-        nodeKey?: string;
-        input?: any;
-    }): Promise<FlowRun>;
-    openConfiguration(options?: OpenFlowInstanceConfigurationOptions): Promise<void>;
-    openEditor(options?: OpenFlowInstanceEditorOptions): Promise<void>;
+interface DataLink {
+    id: string;
+    dataLinkTableInstanceId: string;
+    externalRecordId: string;
+    appRecordId: string;
+    direction: DataLinkDirection;
 }
-declare class ConnectionLevelFlowsAccessor extends ConnectionLevelElementsListAccessor<Flow, ListFlowInstancesForConnectionQuery> {
-    client: IntegrationAppApiClient;
-    connectionSelector: string;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string);
+
+interface BaseAppEventSubscription extends BaseMembraneInterface {
+    revision: string;
+    appEventTypeId: string;
+    userId: string;
+    instanceKey?: string;
+    isSubscribed: boolean;
+    schema?: DataSchema;
+    webhookUri: string;
+    subscriptionRequest: HttpRequestSpec;
+    subscriptionResponse?: any;
+    archivedAt?: string;
 }
 
-interface ListDataSourcesForIntegrationQuery extends PaginationQuery {
-    universalDataSourceId?: string | 'null';
+interface BaseAppDataSchemaInstance extends BaseMembraneInterface {
+    appId: string;
+    userId: string;
+    appDataSchemaId: string;
+    appDataSchemaRevision: string;
+    instanceKey?: string;
+    schema?: any;
+    error?: ErrorData;
+    archivedAt?: string;
 }
-interface FindDataSourcesQuery extends ListDataSourcesForIntegrationQuery {
-    integrationId?: string | 'null';
+
+declare enum ExternalEventSubscriptionStatus {
+    Subscribed = "subscribed",
+    Unsubscribed = "unsubscribed",
+    Error = "error"
 }
-type CreateDataSourceRequest = {
-    key: string;
-    name: string;
-    integrationId?: string;
-    udm?: string;
-    pullUpdatesIntervalSeconds?: number;
-    fullSyncIntervalSeconds?: number;
-    rootPath?: string;
-    defaultPath?: string;
-    collectionKey?: string;
-    collectionParameters?: any;
-};
-type UpdateDataSourceRequest = {
-    key?: string;
+declare enum ExternalEventSubscriptionType {
+    DataRecordCreated = "data-record-created",
+    DataRecordUpdated = "data-record-updated",
+    DataRecordDeleted = "data-record-deleted",
+    ConnectorEvent = "connector-event"
+}
+interface ExternalEventSubscriptionConfig {
+    type: ExternalEventSubscriptionType;
+    dataSource?: DataSourceUnitConfig;
+    eventKey?: string;
+    eventParameters?: any;
+}
+interface BaseExternalEventSubscription {
+    id: string;
     name?: string;
+    userId: string;
+    connectionId: string;
+    integrationId: string;
+    uuid: string;
+    config?: ExternalEventSubscriptionConfig;
+    status?: ExternalEventSubscriptionStatus;
+    error?: ErrorData;
+    isRealTime?: boolean;
+    requiresPull?: boolean;
+    requiresFullSync?: boolean;
+    createdAt?: string;
     archivedAt?: string;
-    udm?: string;
+    stateData?: any;
+    nextPullEventsTimestamp?: number;
     pullUpdatesIntervalSeconds?: number;
     fullSyncIntervalSeconds?: number;
-    rootPath?: string;
-    defaultPath?: string;
-};
-interface DataSourceInstanceSelector extends ConnectionSelector, FlowInstanceSelector, ElementInstanceSelector {
-    dataSourceKey?: string;
-    dataSourceId?: string;
-    instanceKey?: string;
-    nodeKey?: string;
-    udm?: string;
+    nextRefreshTimestamp?: number;
+    globalWebhookKey?: string;
+    globalWebhookEventSelector?: string;
 }
-interface FindDataSourceInstancesQuery extends PaginationQuery {
+
+interface ActionInstance extends BaseActionInstance {
+    user?: BaseCustomer;
+    parent?: BaseAction;
+}
+
+interface FindExternalEventSubscriptionsQuery extends PaginationQuery {
     userId?: string;
-    dataSourceId?: string;
-    universalDataSourceId?: string;
     connectionId?: string;
-    integrationKey?: string;
     integrationId?: string;
 }
-interface CreateDataSourceInstanceRequest {
-    dataSourceId: string;
+
+type ListFieldMappingInstancesForConnectionQuery = CommonInstancesListQuery & {
+    fieldMappingId?: string;
+    universalFieldMappingId?: string;
+    dataSourceInstanceId?: string;
+};
+type FindFieldMappingInstancesQuery = ListFieldMappingInstancesForConnectionQuery & CommonIntegrationOrConnectionQuery;
+interface CreateFieldMappingInstanceRequest {
     connectionId: string;
-    path?: string;
+    fieldMappingId?: string;
+    instanceKey?: string;
+    importValue?: any;
+    exportValue?: any;
 }
-interface UpdateDataSourceInstanceRequest {
-    path?: string;
-    collectionKey?: string;
-    collectionParameters?: any;
-    pullUpdatesIntervalSeconds?: number;
-    fullSyncIntervalSeconds?: number;
-    subscribedTo?: {
-        created?: boolean;
-        updated?: boolean;
-        deleted?: boolean;
-    };
+interface UpdateFieldMappingInstanceRequest {
+    importValue?: any;
+    exportValue?: any;
 }
-type ListDataSourceInstancesForConnectionQuery = PaginationQuery & {
-    dataSourceId?: string;
-};
-
-interface OpenDataSourceConfigurationOptions extends OpenConfigurationOptions {
+interface FieldMappingInstanceSelector extends ConnectionSelector, FlowInstanceSelector, ElementInstanceSelector {
+    fieldMappingKey?: string;
+    fieldMappingId?: string;
+    instanceKey?: string;
+    nodeKey?: string;
 }
-declare class DataSourcesAccessor extends ElementListAccessor<DataSource, FindDataSourcesQuery, CreateDataSourceRequest> {
-    constructor(client: IntegrationAppApiClient);
+interface FieldMappingInstance extends BaseFieldMappingInstance {
+    user?: BaseCustomer;
+    connection?: BaseConnection;
+    integration?: BaseIntegration;
+    fieldMapping?: BaseFieldMapping;
+    dataSourceInstance?: DataSourceInstance;
 }
-declare class DataSourceAccessor extends ElementAccessor<DataSource, UpdateDataSourceRequest, DataSourceSelector> {
-    constructor(client: IntegrationAppApiClient, selector: DataSourceSelector | string);
-    apply(integrationKeys: string[]): Promise<DataSource[]>;
-    setup(): Promise<void>;
-    reset(): Promise<any>;
+
+interface FindDataLinkTableInstancesQuery extends PaginationQuery {
+    connectionId?: string;
+    integrationId?: string;
+    dataLinkTableId?: string;
 }
-declare class DataSourceInstancesAccessor extends ElementInstanceListAccessor<DataSourceInstance, FindDataSourceInstancesQuery> {
-    constructor(client: IntegrationAppApiClient);
+interface DataLinkTableInstanceSelector extends ConnectionSelector, ElementInstanceSelector {
+    dataLinkTableId?: string;
+    dataLinkTableKey?: string;
+    instanceKey?: string;
 }
-declare class DataSourceInstanceAccessor extends ElementInstanceAccessor<DataSourceInstance, DataSourceInstanceSelector, CreateDataSourceInstanceRequest, UpdateDataSourceInstanceRequest> {
-    client: IntegrationAppApiClient;
-    constructor(client: IntegrationAppApiClient, selector: string | DataSourceInstanceSelector);
-    setup(): Promise<void>;
-    reset(): Promise<void>;
-    openConfiguration({ onClose }?: OpenDataSourceConfigurationOptions): Promise<void>;
-    unifiedFieldsToNative(unifiedFields: any): Promise<any>;
-    getCollection(): Promise<DataCollectionSpec>;
-    listRecords(request?: DataCollectionListRequest): Promise<DataCollectionListResponse>;
-    matchRecord(request: DataCollectionMatchRequest): Promise<DataCollectionMatchResponse>;
-    searchRecords(request: DataCollectionSearchRequest): Promise<DataCollectionSearchResponse>;
-    findRecordById(request: string | DataCollectionFindByIdRequest): Promise<DataCollectionFindByIdResponse>;
-    createRecord(request: DataCollectionCreateRequest): Promise<DataCollectionCreateResponse>;
-    updateRecord(request: DataCollectionUpdateRequest): Promise<DataCollectionUpdateResponse>;
-    deleteRecord(request: string | DataCollectionFindByIdRequest): Promise<DataCollectionDeleteResponse>;
-    findRecords(request?: DataCollectionFindRequest): Promise<DataCollectionFindResponse>;
+interface UpdateDataLinkTableInstanceRequest {
 }
-declare class IntegrationLevelDataSourceAccessor extends IntegrationLevelElementAccessor<DataSource, UpdateDataSourceRequest> {
-    client: IntegrationAppApiClient;
-    integrationSelector: string;
-    dataSourceSelector: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string, dataSourceSelector: string);
+interface FindDataLinksInTableQuery extends PaginationQuery {
+    direction?: DataLinkDirection;
+    appRecordId?: string;
+    externalRecordId?: string;
 }
-declare class IntegrationLevelDataSourcesListAccessor extends IntegrationLevelElementsListAccessor<DataSource, ListDataSourcesForIntegrationQuery, Omit<CreateDataSourceRequest, 'integrationId'>> {
-    client: IntegrationAppApiClient;
-    integrationSelector: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string);
+interface CreateDataLinkRequest {
+    direction?: DataLinkDirection;
+    appRecordId: string;
+    externalRecordId: string;
 }
-declare class ConnectionLevelDataSourceAccessor extends ConnectionLevelElementAccessor<DataSourceInstance, UpdateDataSourceInstanceRequest> {
-    client: IntegrationAppApiClient;
-    connectionSelector: string;
-    dataSourceSelector: string;
-    query: InstanceKeyQuery;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string, dataSourceSelector: string, query: InstanceKeyQuery);
-    openConfiguration(options?: OpenDataSourceConfigurationOptions): Promise<void>;
+interface DeleteDataLinkRequest {
+    direction?: DataLinkDirection;
+    appRecordId: string;
+    externalRecordId: string;
 }
-declare class ConnectionLevelDataSourcesAccessor extends ConnectionLevelElementsListAccessor<DataSource, ListDataSourceInstancesForConnectionQuery> {
-    client: IntegrationAppApiClient;
-    connectionSelector: string;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string);
+interface FindDataLinksResponse extends PaginationResponse<DataLink> {
+}
+interface DataLinkTableInstance extends BaseDataLinkTableInstance {
+    dataLinkTable?: BaseDataLinkTable;
+    connection?: BaseConnection;
+    integration?: BaseIntegration;
+    user?: BaseCustomer;
 }
 
-interface DataSourceUnitConfig {
-    key?: string;
-    collectionKey?: any;
-    collectionParameters?: any;
-    udm?: any;
-    path?: string;
-    pullUpdatesIntervalSeconds?: number;
-    fullSyncIntervalSeconds?: number;
+interface FindAppEventSubscriptionsQuery extends PaginationQuery {
+    id?: string;
+    userId?: string;
+    instanceKey?: string;
+    appEventTypeId?: string;
+    isSubscribed?: boolean;
 }
-interface DataSource extends WorkspaceElement {
-    revision: string;
-    publishedRevision?: string;
-    integrationId?: string;
-    integration?: Integration;
-    universalDataSourceId?: string;
-    universalDataSourceRevision?: string;
-    udm?: string;
-    pullUpdatesIntervalSeconds?: number;
-    fullSyncIntervalSeconds?: number;
-    collectionKey?: string;
-    collectionParameters?: any;
-    archivedAt?: string;
-    createdAt?: string;
-    updatedAt?: string;
-    customized?: boolean;
-    appliedToIntegrations?: AppliedToIntegrations<DataSource>;
-    defaultPath?: string;
+interface UpdateAppEventSubscriptionRequest {
 }
-interface DataSourceInstance extends WorkspaceElement {
-    userId: string;
-    revision: string;
-    user?: User;
-    dataSourceRevision?: string;
-    dataSourceId?: string;
-    universalDataSourceId?: string;
-    dataSource?: DataSource;
-    udm?: string;
-    connectionId: string;
-    connection?: Connection;
-    integrationId: string;
-    integration?: Integration;
+interface AppEventSubscriptionSelector extends Omit<ElementInstanceSelector, 'parentKey' | 'parentId'> {
+    appEventTypeKey?: string;
+    appEventTypeId?: string;
     instanceKey?: string;
-    collectionKey?: string;
-    collectionParameters?: any;
-    defaultCollectionKey?: string;
-    defaultCollectionParameters?: any;
-    collectionSpec?: DataCollectionSpec;
-    isCustomized?: boolean;
-    errors?: ErrorData[];
-    pullUpdatesIntervalSeconds?: number;
-    fullSyncIntervalSeconds?: number;
-    path?: string;
-    defaultPath?: string;
 }
-interface DataSourceSelector extends IntegrationSpecificElementSelector {
+interface AppEventSubscription extends BaseAppEventSubscription {
+    appEventType?: BaseAppEventType;
+    user?: BaseCustomer;
 }
 
-declare class ConnectionsAccessor extends ElementInstanceListAccessor<Connection, FindConnectionsQuery> {
-    constructor(client: IntegrationAppApiClient);
-    create(data: CreateConnectionRequest): Promise<Connection>;
-}
-declare class ConnectionAccessor {
-    client: IntegrationAppApiClient;
-    connectionSelector: string;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string);
-    get actions(): ConnectionLevelActionsAccessor;
-    action(actionSelector: string, query?: InstanceKeyQuery): ConnectionLevelActionAccessor;
-    get flows(): ConnectionLevelFlowsAccessor;
-    flow(flowSelector: string, query?: InstanceKeyQuery): ConnectionLevelFlowAccessor;
-    get dataSources(): ConnectionLevelDataSourcesAccessor;
-    dataSource(dataSourceSelector: string, query?: InstanceKeyQuery): ConnectionLevelDataSourceAccessor;
-    get fieldMappings(): ConnectionLevelFieldMappingsAccessor;
-    fieldMapping(fieldMappingSelector: string, query?: InstanceKeyQuery): ConnectionLevelFieldMappingAccessor;
-    get(query?: {
-        includeSecrets?: boolean;
-    }): Promise<Connection>;
-    patch(data: UpdateConnectionRequest): Promise<Connection>;
-    put(data: UpdateConnectionRequest): Promise<Connection>;
-    archive(): Promise<void>;
-    request(path: string, data?: any): Promise<any>;
-    get proxy(): ConnectionProxy;
-    operation(key: string): ConnectionOperationAccessor;
-    dataCollection(key: string, parameters?: Record<string, any>): ConnectionDataCollectionAccessor;
-    dataDirectory(key: string, parameters?: Record<string, any>): ConnectionDataDirectoryAccessor;
-    reconnect({ parameters, authOptionKey, connectorParameters, }?: {
-        parameters?: any;
-        authOptionKey?: string;
-        connectorParameters?: any;
-    }): Promise<Connection | undefined>;
-    openReconnectUI({}?: OpenConfigurationOptions): Promise<void>;
-    refreshCredentials(): Promise<void>;
-    getPath(subpath?: string, query?: Record<string, any>): string;
+interface FindAppDataSchemaInstancesQuery extends PaginationQuery {
+    id?: string;
+    userId?: string;
+    appDataSchemaId?: string;
+    instanceKey?: string;
 }
-declare class ConnectionOperationAccessor {
-    client: IntegrationAppApiClient;
-    connectionAccessor: ConnectionAccessor;
-    key: string;
-    constructor(client: IntegrationAppApiClient, connectionAccessor: ConnectionAccessor, key: string);
-    get(): Promise<OperationSpec>;
-    run(request?: OperationRunRequest): Promise<OperationRunResponse>;
+interface AppDataSchemaInstanceSelector {
+    id?: string;
+    appDataSchemaKey?: string;
+    appDataSchemaId?: string;
+    instanceKey?: string;
+    autoCreate?: boolean;
 }
-declare class ConnectionDataDirectoryAccessor {
-    client: IntegrationAppApiClient;
-    connectionAccessor: ConnectionAccessor;
-    key: string;
-    parameters: Record<string, any>;
-    constructor(client: IntegrationAppApiClient, connectionAccessor: ConnectionAccessor, key: string, parameters: Record<string, any>);
-    list(request?: DataDirectoryListRequest): Promise<DataDirectoryListResponse>;
+interface UpdateAppDataSchemaInstanceRequest {
 }
-declare class ConnectionDataCollectionAccessor {
-    client: IntegrationAppApiClient;
-    connectionAccessor: ConnectionAccessor;
-    key: string;
-    parameters: Record<string, any>;
-    constructor(client: IntegrationAppApiClient, connectionAccessor: ConnectionAccessor, key: string, parameters: Record<string, any>);
-    get(): Promise<DataCollectionSpec>;
-    findById(request?: DataCollectionFindByIdRequest): Promise<DataCollectionFindByIdResponse>;
-    list(request?: DataCollectionListRequest): Promise<DataCollectionListResponse>;
-    search(request?: DataCollectionSearchRequest): Promise<DataCollectionSearchResponse>;
-    match(request?: DataCollectionMatchRequest): Promise<DataCollectionMatchResponse>;
-    create(request?: DataCollectionCreateRequest): Promise<DataCollectionCreateResponse>;
-    update(request?: DataCollectionUpdateRequest): Promise<DataCollectionUpdateResponse>;
-    delete(request?: DataCollectionDeleteRequest): Promise<DataCollectionDeleteResponse>;
+interface CreateAppDataSchemaInstanceRequest {
 }
-declare class ConnectionProxy {
-    private connection;
-    constructor(connection: ConnectionAccessor);
-    get(path: string): Promise<any>;
-    post(path: string, data?: any): Promise<any>;
-    put(path: string, data?: any): Promise<any>;
-    patch(path: string, data?: any): Promise<any>;
-    delete(path: string): Promise<any>;
-    private getProxyPath;
+interface AppDataSchemaInstance extends BaseAppDataSchemaInstance {
+    user?: BaseCustomer;
+    appDataSchema?: BaseAppDataSchema;
 }
 
-declare class Connection {
-    id: string;
-    name: string;
-    userId: string;
-    user?: User;
-    disconnected?: boolean;
-    error?: ErrorData;
-    integrationId: string;
-    integration?: Integration;
-    credentials?: unknown;
-    parameters?: unknown;
-    connectorParameters?: unknown;
-    accessToken?: string;
-    refreshToken?: string;
-    createdAt: string;
-    updatedAt: string;
+interface ExternalEventSubscription extends BaseExternalEventSubscription {
+    user?: BaseCustomer;
+    connection?: BaseConnection;
+    integration?: BaseIntegration;
+}
+
+interface BaseIntegration extends BaseMembraneInterface {
+    logoUri: string;
+    connectorId?: string;
+    connectorVersion?: string;
+    authOptions?: IntegrationAuthOption[];
+    oAuthCallbackUri?: string;
+    parametersSchema?: DataSchema;
+    parameters?: any;
+    baseUri: string;
     archivedAt?: string;
+    hasMissingParameters?: boolean;
+    hasDocumentation?: boolean;
+    hasOperations?: boolean;
+    hasData?: boolean;
+    hasEvents?: boolean;
+    hasGlobalWebhooks?: boolean;
+    hasUdm?: boolean;
+    isTest?: boolean;
+    appUuid?: string;
+    isDeactivated?: boolean;
+    authType?: ConnectorAuthType;
 }
-interface ConnectionSpec extends ConnectorSpec {
+type IntegrationAuthOption = ConnectorAuthSpec & {
+    key: string;
+};
+type AppliedToIntegrations<Element> = {
+    element: Element;
+    integration: BaseIntegration;
+}[];
+
+interface FindConnectionsQuery extends PaginationQuery {
+    userId?: string;
+    isTest?: boolean;
+    integrationKey?: string;
+    integrationId?: string;
+    includeArchived?: boolean;
 }
-declare class ConnectionSpec {
-    constructor(opts: ConnectionSpec);
+declare class CreateConnectionRequest {
+    name: string;
+    integrationId: string;
+    credentials?: string;
 }
-
-declare enum ActionType {
-    ListDataRecords = "list-data-records",
-    FindDataRecordById = "find-data-record-by-id",
-    MatchDataRecord = "match-data-record",
-    CreateDataRecord = "create-data-record",
-    FindOrCreateDataRecord = "find-or-create-data-record",
-    UpdateDataRecord = "update-data-record",
-    DeleteDataRecord = "delete-data-record",
-    SearchDataRecords = "search-data-record",
-    ConnectorOperation = "connector-operation",
-    ApiRequestToExternalApp = "api-request-to-external-app",
-    ApiRequestToYourApp = "api-request-to-your-app",
-    HttpRequest = "http-request",
-    RunJavascript = "run-javascript",
-    ApiRequest = "api-request"
+declare class UpdateConnectionRequest {
+    name?: string;
+    credentials?: string;
+    accessToken?: string;
 }
-
-interface Action extends ElementTemplateFields {
-    type: ActionType;
-    inputSchema?: DataSchema;
-    config?: any;
-    outputMapping?: any;
-    customOutputSchema?: DataSchema;
-    defaultOutputSchema?: DataSchema;
-    transformedOutputSchema?: DataSchema;
-    outputSchema?: DataSchema;
-    appliedToIntegrations?: AppliedToIntegrations<Action>;
-    dependencies?: WorkspaceElementDependency[];
+interface ConnectionSelector {
+    id?: string;
+    integrationKey?: string;
+    integrationId?: string;
+    connectionId?: string;
 }
-interface ActionInstance extends ElementInstanceFields {
-    type: ActionType;
-    parent?: Action;
-    instanceKey?: string;
-    inputSchema?: any;
-    config?: any;
-    outputSchema?: any;
-    isOutdated?: boolean;
-    state: WorkspaceElementState;
+interface Connection extends BaseConnection {
+    user?: BaseCustomer;
+    integration?: BaseIntegration;
 }
+
 interface ListActionsForIntegrationQuery extends PaginationQuery {
     parentId?: string | 'null';
 }
@@ -2047,6 +3054,10 @@ interface ActionRunResponse {
     output?: any;
     logs?: any[];
 }
+interface Action extends BaseAction {
+    integration?: BaseIntegration;
+    appliedToIntegrations?: AppliedToIntegrations<Action>;
+}
 
 declare class ActionsAccessor extends ElementListAccessor<Action, FindActionsQuery, CreateActionRequest> {
     constructor(client: IntegrationAppApiClient);
@@ -2056,6 +3067,50 @@ declare class ActionAccessor extends ElementAccessor<Action, UpdateActionRequest
     apply(integrationKeys: string[]): Promise<Action[]>;
     reset(): Promise<any>;
 }
+declare class IntegrationLevelActionAccessor extends IntegrationLevelElementAccessor<Action, UpdateActionRequest> {
+    client: IntegrationAppApiClient;
+    integrationSelector: string;
+    actionSelector: string;
+    constructor(client: IntegrationAppApiClient, integrationSelector: string, actionSelector: string);
+}
+declare class IntegrationLevelActionsListAccessor extends IntegrationLevelElementsListAccessor<Action, ListActionsForIntegrationQuery, Omit<CreateActionRequest, 'integrationId'>> {
+    client: IntegrationAppApiClient;
+    integrationSelector: string;
+    constructor(client: IntegrationAppApiClient, integrationSelector: string);
+}
+
+type InstanceKeyQuery = {
+    instanceKey?: string;
+};
+
+declare class ConnectionLevelElementAccessor<Element, UpdateElement> {
+    protected client: IntegrationAppApiClient;
+    protected connectionSelector: string;
+    protected selector: string;
+    protected elementKey: string;
+    protected query: Record<string, any>;
+    protected endpoint: string;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string, selector: string, elementKey: string, query: Record<string, any>);
+    protected uri(path?: string, query?: {}): string;
+    getUniqueIdentifier(): string;
+    get(query?: {
+        autoCreate?: boolean;
+    }): Promise<Element>;
+    create(): Promise<Element>;
+    patch(data: Partial<UpdateElement>): Promise<Element>;
+    put(data: UpdateElement): Promise<Element>;
+    archive(): Promise<void>;
+    reset(): Promise<Element>;
+    setup(): Promise<Element>;
+}
+declare class ConnectionLevelElementsListAccessor<Element, Query> {
+    protected client: IntegrationAppApiClient;
+    protected connectionSelector: string;
+    protected elementKey: string;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string, elementKey: string);
+    list(query?: Query): Promise<PaginationResponse<Element[]>>;
+}
+
 declare class ActionInstancesAccessor extends ElementInstanceListAccessor<ActionInstance, FindActionInstancesQuery> {
     constructor(client: IntegrationAppApiClient);
 }
@@ -2067,240 +3122,364 @@ declare class ActionInstanceAccessor extends ElementInstanceAccessor<ActionInsta
     run(input?: any): Promise<ActionRunResponse>;
     open({ onClose }?: OpenActionConfigurationOptions): Promise<void>;
 }
-declare class IntegrationLevelActionAccessor extends IntegrationLevelElementAccessor<Action, UpdateActionRequest> {
+declare class ConnectionLevelActionAccessor extends ConnectionLevelElementAccessor<ActionInstance, UpdateActionInstanceRequest> {
     client: IntegrationAppApiClient;
-    integrationSelector: string;
+    connectionSelector: string;
     actionSelector: string;
-    constructor(client: IntegrationAppApiClient, integrationSelector: string, actionSelector: string);
+    query: InstanceKeyQuery;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string, actionSelector: string, query: InstanceKeyQuery);
+    run(input?: any): Promise<ActionRunResponse>;
 }
-declare class IntegrationLevelActionsListAccessor extends IntegrationLevelElementsListAccessor<Action, ListActionsForIntegrationQuery, Omit<CreateActionRequest, 'integrationId'>> {
+declare class ConnectionLevelActionsAccessor extends ConnectionLevelElementsListAccessor<ActionInstance, ListActionInstancesForConnectionQuery> {
+    client: IntegrationAppApiClient;
+    connectionSelector: string;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string);
+}
+
+interface OpenDataSourceConfigurationOptions extends OpenConfigurationOptions {
+}
+declare class DataSourcesAccessor extends ElementListAccessor<DataSource, FindDataSourcesQuery, CreateDataSourceRequest> {
+    constructor(client: IntegrationAppApiClient);
+}
+declare class DataSourceAccessor extends ElementAccessor<DataSource, UpdateDataSourceRequest, DataSourceSelector> {
+    constructor(client: IntegrationAppApiClient, selector: DataSourceSelector | string);
+    apply(integrationKeys: string[]): Promise<DataSource[]>;
+    setup(): Promise<void>;
+    reset(): Promise<any>;
+}
+declare class DataSourceInstancesAccessor extends ElementInstanceListAccessor<DataSourceInstance, FindDataSourceInstancesQuery> {
+    constructor(client: IntegrationAppApiClient);
+}
+declare class DataSourceInstanceAccessor extends ElementInstanceAccessor<DataSourceInstance, DataSourceInstanceSelector, CreateDataSourceInstanceRequest, UpdateDataSourceInstanceRequest> {
+    client: IntegrationAppApiClient;
+    constructor(client: IntegrationAppApiClient, selector: string | DataSourceInstanceSelector);
+    setup(): Promise<void>;
+    reset(): Promise<void>;
+    openConfiguration({ onClose }?: OpenDataSourceConfigurationOptions): Promise<void>;
+    unifiedFieldsToNative(unifiedFields: any): Promise<any>;
+    getCollection(): Promise<DataCollectionSpec>;
+    listRecords(request?: DataCollectionListRequest): Promise<DataCollectionListResponse>;
+    matchRecord(request: DataCollectionMatchRequest): Promise<DataCollectionMatchResponse>;
+    searchRecords(request: DataCollectionSearchRequest): Promise<DataCollectionSearchResponse>;
+    findRecordById(request: string | DataCollectionFindByIdRequest): Promise<DataCollectionFindByIdResponse>;
+    createRecord(request: DataCollectionCreateRequest): Promise<DataCollectionCreateResponse>;
+    updateRecord(request: DataCollectionUpdateRequest): Promise<DataCollectionUpdateResponse>;
+    deleteRecord(request: string | DataCollectionFindByIdRequest): Promise<DataCollectionDeleteResponse>;
+    findRecords(request?: DataCollectionFindRequest): Promise<DataCollectionFindResponse>;
+}
+declare class IntegrationLevelDataSourceAccessor extends IntegrationLevelElementAccessor<DataSource, UpdateDataSourceRequest> {
+    client: IntegrationAppApiClient;
+    integrationSelector: string;
+    dataSourceSelector: string;
+    constructor(client: IntegrationAppApiClient, integrationSelector: string, dataSourceSelector: string);
+}
+declare class IntegrationLevelDataSourcesListAccessor extends IntegrationLevelElementsListAccessor<DataSource, ListDataSourcesForIntegrationQuery, Omit<CreateDataSourceRequest, 'integrationId'>> {
     client: IntegrationAppApiClient;
     integrationSelector: string;
     constructor(client: IntegrationAppApiClient, integrationSelector: string);
 }
-declare class ConnectionLevelActionAccessor extends ConnectionLevelElementAccessor<ActionInstance, UpdateActionInstanceRequest> {
+declare class ConnectionLevelDataSourceAccessor extends ConnectionLevelElementAccessor<DataSourceInstance, UpdateDataSourceInstanceRequest> {
     client: IntegrationAppApiClient;
     connectionSelector: string;
-    actionSelector: string;
+    dataSourceSelector: string;
+    query: InstanceKeyQuery;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string, dataSourceSelector: string, query: InstanceKeyQuery);
+    openConfiguration(options?: OpenDataSourceConfigurationOptions): Promise<void>;
+}
+declare class ConnectionLevelDataSourcesAccessor extends ConnectionLevelElementsListAccessor<DataSource, ListDataSourceInstancesForConnectionQuery> {
+    client: IntegrationAppApiClient;
+    connectionSelector: string;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string);
+}
+
+interface OpenFieldMappingInstanceConfigurationOptions extends OpenConfigurationOptions {
+}
+declare class FieldMappingInstancesAccessor extends ElementInstanceListAccessor<FieldMappingInstance, FindFieldMappingInstancesQuery> {
+    constructor(client: IntegrationAppApiClient);
+}
+declare class FieldMappingInstanceAccessor extends ElementInstanceAccessor<FieldMappingInstance, FieldMappingInstanceSelector, CreateFieldMappingInstanceRequest, UpdateFieldMappingInstanceRequest> {
+    private client;
+    constructor(client: IntegrationAppApiClient, selector: string | FieldMappingInstanceSelector);
+    setup(): Promise<void>;
+    reset(): Promise<void>;
+    openConfiguration({ onClose }?: OpenFieldMappingInstanceConfigurationOptions): Promise<void>;
+}
+declare class ConnectionLevelFieldMappingAccessor extends ConnectionLevelElementAccessor<FieldMappingInstance, UpdateFieldMappingInstanceRequest> {
+    client: IntegrationAppApiClient;
+    connectionSelector: string;
+    fieldMappingSelector: string;
     query: InstanceKeyQuery;
-    constructor(client: IntegrationAppApiClient, connectionSelector: string, actionSelector: string, query: InstanceKeyQuery);
-    run(input?: any): Promise<ActionRunResponse>;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string, fieldMappingSelector: string, query: InstanceKeyQuery);
+    openConfiguration({ onClose }?: OpenFieldMappingInstanceConfigurationOptions): Promise<void>;
 }
-declare class ConnectionLevelActionsAccessor extends ConnectionLevelElementsListAccessor<Action, ListActionInstancesForConnectionQuery> {
+declare class ConnectionLevelFieldMappingsAccessor extends ConnectionLevelElementsListAccessor<FieldMappingInstance, ListFieldMappingInstancesForConnectionQuery> {
     client: IntegrationAppApiClient;
     connectionSelector: string;
     constructor(client: IntegrationAppApiClient, connectionSelector: string);
 }
 
-type CreateAppDataSchemaRequest = {
-    key: string;
-    name: string;
-    schema?: any;
-    code?: string;
-};
-type UpdateAppDataSchemaRequest = {
-    key?: string;
-    name?: string;
-    schema?: any;
-    code?: string;
-    archivedAt?: string;
-};
-interface FindAppDataSchemasQuery extends PaginationQuery {
-}
-interface AppDataSchemaInstanceSelector {
-    id?: string;
-    appDataSchemaKey?: string;
-    appDataSchemaId?: string;
-    instanceKey?: string;
-    autoCreate?: boolean;
-}
-interface UpdateAppDataSchemaInstanceRequest {
-}
-interface CreateAppDataSchemaInstanceRequest {
+interface OpenFlowInstanceConfigurationOptions extends OpenConfigurationOptions {
+    nodeKey?: string;
 }
-interface FindAppDataSchemaInstancesQuery extends PaginationQuery {
-    id?: string;
-    userId?: string;
-    appDataSchemaId?: string;
-    instanceKey?: string;
+interface OpenFlowInstanceEditorOptions extends OpenConfigurationOptions {
 }
-
-declare class AppDataSchemasAccessor extends ElementListAccessor<AppDataSchema, FindAppDataSchemasQuery, CreateAppDataSchemaRequest> {
+declare class FlowInstancesAccessor extends ElementInstanceListAccessor<FlowInstance, FindFlowInstancesQuery> {
     constructor(client: IntegrationAppApiClient);
+    create(data: CreateFlowInstanceRequest): Promise<FlowInstance>;
 }
-declare class AppDataSchemaAccessor extends ElementAccessor<AppDataSchema, UpdateAppDataSchemaRequest> {
-    constructor(client: IntegrationAppApiClient, idOrKey: string);
+declare class FlowInstanceAccessor extends ElementInstanceAccessor<FlowInstance, FlowInstanceSelector, CreateFlowInstanceRequest, UpdateFlowInstanceRequest> {
+    protected client: IntegrationAppApiClient;
+    protected selector: FlowInstanceSelector | string;
+    constructor(client: IntegrationAppApiClient, selector: FlowInstanceSelector | string);
+    enable(): Promise<FlowInstance>;
+    disable(): Promise<FlowInstance>;
+    updateToLatestFlow(): Promise<FlowInstance>;
+    setup(): Promise<FlowInstance>;
+    reset(options?: ResetFlowInstanceOptions): Promise<FlowInstance>;
+    openConfiguration({ nodeKey, onClose }?: OpenFlowInstanceConfigurationOptions): Promise<void>;
+    openEditor({ onClose }?: OpenFlowInstanceEditorOptions): Promise<void>;
+    embedEditor({ mountTargetSelector, onClose, }?: {
+        mountTargetSelector?: string;
+    } & OpenFlowInstanceEditorOptions): Promise<void>;
+    startRun(options?: RunFlowOptions): Promise<FlowRun>;
+    run(options?: RunFlowOptions): Promise<FlowRun>;
 }
-declare class AppDataSchemaInstancesAccessor extends ElementInstanceListAccessor<AppDataSchemaInstance, FindAppDataSchemaInstancesQuery> {
-    constructor(client: IntegrationAppApiClient);
+declare class ConnectionLevelFlowAccessor extends ConnectionLevelElementAccessor<FlowInstance, UpdateFlowInstanceRequest> {
+    client: IntegrationAppApiClient;
+    connectionSelector: string;
+    flowSelector: string;
+    query: InstanceKeyQuery;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string, flowSelector: string, query: InstanceKeyQuery);
+    enable(): Promise<FlowInstance>;
+    disable(): Promise<FlowInstance>;
+    run(options: {
+        nodeKey?: string;
+        input?: any;
+    }): Promise<FlowRun>;
+    openConfiguration(options?: OpenFlowInstanceConfigurationOptions): Promise<void>;
+    openEditor(options?: OpenFlowInstanceEditorOptions): Promise<void>;
 }
-declare class AppDataSchemaInstanceAccessor extends ElementInstanceAccessor<AppDataSchemaInstance, AppDataSchemaInstanceSelector, UpdateAppDataSchemaInstanceRequest, CreateAppDataSchemaInstanceRequest> {
-    private client;
-    constructor(client: IntegrationAppApiClient, selector: string | AppDataSchemaInstanceSelector);
-    setup(): Promise<void>;
+declare class ConnectionLevelFlowsAccessor extends ConnectionLevelElementsListAccessor<FlowInstance, ListFlowInstancesForConnectionQuery> {
+    client: IntegrationAppApiClient;
+    connectionSelector: string;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string);
 }
 
-interface AppDataSchema extends WorkspaceElement {
-    schema: any;
-    code?: string;
-    archivedAt?: string;
-    revision?: string;
+declare class ConnectionsAccessor extends ElementInstanceListAccessor<Connection, FindConnectionsQuery> {
+    constructor(client: IntegrationAppApiClient);
+    create(data: CreateConnectionRequest): Promise<Connection>;
 }
-interface AppDataSchemaInstance extends WorkspaceElement {
-    appId: string;
-    userId: string;
-    user?: User;
-    appDataSchemaId: string;
-    appDataSchemaRevision: string;
-    appDataSchema?: AppDataSchema;
-    instanceKey?: string;
-    schema?: any;
-    error?: ErrorData;
-    archivedAt?: string;
+declare class ConnectionAccessor {
+    client: IntegrationAppApiClient;
+    connectionSelector: string;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string);
+    get actions(): ConnectionLevelActionsAccessor;
+    action(actionSelector: string, query?: InstanceKeyQuery): ConnectionLevelActionAccessor;
+    get flows(): ConnectionLevelFlowsAccessor;
+    flow(flowSelector: string, query?: InstanceKeyQuery): ConnectionLevelFlowAccessor;
+    get dataSources(): ConnectionLevelDataSourcesAccessor;
+    dataSource(dataSourceSelector: string, query?: InstanceKeyQuery): ConnectionLevelDataSourceAccessor;
+    get fieldMappings(): ConnectionLevelFieldMappingsAccessor;
+    fieldMapping(fieldMappingSelector: string, query?: InstanceKeyQuery): ConnectionLevelFieldMappingAccessor;
+    get(query?: {
+        includeSecrets?: boolean;
+    }): Promise<Connection>;
+    patch(data: UpdateConnectionRequest): Promise<Connection>;
+    put(data: UpdateConnectionRequest): Promise<Connection>;
+    archive(): Promise<void>;
+    request(path: string, data?: any): Promise<any>;
+    get proxy(): ConnectionProxy;
+    operation(key: string): ConnectionOperationAccessor;
+    dataCollection(key: string, parameters?: Record<string, any>): ConnectionDataCollectionAccessor;
+    reconnect({ parameters, authOptionKey, connectorParameters, }?: {
+        parameters?: any;
+        authOptionKey?: string;
+        connectorParameters?: any;
+    }): Promise<Connection | undefined>;
+    openReconnectUI({}?: OpenConfigurationOptions): Promise<void>;
+    refreshCredentials(): Promise<void>;
+    getPath(subpath?: string, query?: Record<string, any>): string;
 }
-
-interface UpdateAppEventTypeRequest {
-    key?: string;
-    name?: string;
-    subscribeRequest?: HttpRequestSpec;
-    example?: any;
-    schema?: DataSchema;
-    userIdFormula?: any;
+declare class ConnectionOperationAccessor {
+    client: IntegrationAppApiClient;
+    connectionAccessor: ConnectionAccessor;
+    key: string;
+    constructor(client: IntegrationAppApiClient, connectionAccessor: ConnectionAccessor, key: string);
+    get(): Promise<OperationSpec>;
+    run(request?: OperationRunRequest): Promise<OperationRunResponse>;
 }
-interface CreateAppEventTypeRequest extends UpdateAppEventTypeRequest {
+declare class ConnectionDataCollectionAccessor {
+    client: IntegrationAppApiClient;
+    connectionAccessor: ConnectionAccessor;
     key: string;
-    name: string;
+    parameters: Record<string, any>;
+    constructor(client: IntegrationAppApiClient, connectionAccessor: ConnectionAccessor, key: string, parameters: Record<string, any>);
+    get(): Promise<DataCollectionSpec>;
+    findById(request?: DataCollectionFindByIdRequest): Promise<DataCollectionFindByIdResponse>;
+    list(request?: DataCollectionListRequest): Promise<DataCollectionListResponse>;
+    search(request?: DataCollectionSearchRequest): Promise<DataCollectionSearchResponse>;
+    match(request?: DataCollectionMatchRequest): Promise<DataCollectionMatchResponse>;
+    create(request?: DataCollectionCreateRequest): Promise<DataCollectionCreateResponse>;
+    update(request?: DataCollectionUpdateRequest): Promise<DataCollectionUpdateResponse>;
+    delete(request?: DataCollectionDeleteRequest): Promise<DataCollectionDeleteResponse>;
 }
-interface AppEventSubscriptionSelector extends Omit<ElementInstanceSelector, 'parentKey' | 'parentId'> {
-    appEventTypeKey?: string;
-    appEventTypeId?: string;
-    instanceKey?: string;
+declare class ConnectionProxy {
+    private connection;
+    constructor(connection: ConnectionAccessor);
+    get(path: string): Promise<any>;
+    post(path: string, data?: any): Promise<any>;
+    put(path: string, data?: any): Promise<any>;
+    patch(path: string, data?: any): Promise<any>;
+    delete(path: string): Promise<any>;
+    private getProxyPath;
 }
-interface AppEventSubscriptionUpdateRequest {
+
+declare class FlowsAccessor extends ElementListAccessor<Flow, FindFlowsQuery, CreateFlowRequest> {
+    constructor(client: IntegrationAppApiClient);
 }
-interface FindAppEventTypesQuery extends PaginationQuery {
-    includeArchived?: boolean;
+declare class FlowAccessor extends ElementAccessor<Flow, UpdateFlowRequest, FlowSelector> {
+    constructor(client: IntegrationAppApiClient, selector: FlowSelector | string);
+    apply(integrationKeys: string[]): Promise<Flow[]>;
+    reset(): Promise<Flow>;
 }
-interface FindAppEventSubscriptionsQuery extends PaginationQuery {
-    id?: string;
-    userId?: string;
-    instanceKey?: string;
-    appEventTypeId?: string;
-    isSubscribed?: boolean;
+declare class IntegrationLevelFlowAccessor extends IntegrationLevelElementAccessor<Flow, UpdateFlowRequest> {
+    client: IntegrationAppApiClient;
+    integrationSelector: string;
+    flowSelector: string;
+    constructor(client: IntegrationAppApiClient, integrationSelector: string, flowSelector: string);
 }
-interface FindAppEventsQuery extends PaginationQuery {
-    id?: string;
-    userId?: string;
-    instanceKey?: string;
-    appEventTypeId?: string;
-    appEventSubscriptionId?: string;
-    startDatetime?: string;
-    endDatetime?: string;
+declare class IntegrationLevelFlowsListAccessor extends IntegrationLevelElementsListAccessor<Flow, ListFlowsForIntegrationQuery, Omit<CreateFlowRequest, 'integrationId'>> {
+    client: IntegrationAppApiClient;
+    integrationSelector: string;
+    constructor(client: IntegrationAppApiClient, integrationSelector: string);
 }
 
-declare class AppEventTypesAccessor extends ElementListAccessor<AppEventType, FindAppEventTypesQuery, CreateAppEventTypeRequest> {
-    constructor(client: IntegrationAppApiClient);
-}
-declare class AppEventTypeAccessor extends ElementAccessor<AppEventType, UpdateAppEventTypeRequest> {
-    constructor(client: IntegrationAppApiClient, idOrKey: string);
+interface OpenFlowRunEditorOptions extends OpenConfigurationOptions {
 }
-declare class AppEventSubscriptionsAccessor extends ElementInstanceListAccessor<AppEventSubscription, FindAppEventSubscriptionsQuery> {
+declare class FlowRunsAccessor {
+    private readonly client;
     constructor(client: IntegrationAppApiClient);
+    find(query: FindFlowRunsQuery): Promise<FindFlowRunsResponse>;
+    create(request: CreateFlowRunRequest): Promise<FlowRun>;
 }
-declare class AppEventSubscriptionAccessor extends ElementInstanceAccessor<AppEventSubscription, AppEventSubscriptionSelector, AppEventSubscriptionUpdateRequest, AppEventSubscriptionUpdateRequest> {
-    constructor(client: IntegrationAppApiClient, selector: string | AppEventSubscriptionSelector);
-    subscribe(): Promise<void>;
+declare class FlowRunAccessor {
+    private readonly client;
+    id: string;
+    private baseUri;
+    constructor(client: IntegrationAppApiClient, id: string);
+    get(): Promise<FlowRun>;
+    stop(): Promise<void>;
+    getOutput(): Promise<any>;
+    getNodeRuns(nodeKey: string, parameters?: {
+        cursor?: string;
+    }): Promise<any>;
+    getNodeRun(nodeKey: string, runId: string): Promise<any>;
+    getNodeOutputs(nodeKey: string, parameters?: {
+        cursor?: string;
+    }): Promise<any>;
+    getNodeOutput(nodeKey: string, outputId: string): Promise<any>;
+    repeat(): Promise<FlowRun>;
+    openEditor({ onClose }?: OpenFlowRunEditorOptions): Promise<void>;
+    embedEditor({ mountTargetSelector, onClose, }?: {
+        mountTargetSelector?: string;
+    } & OpenFlowRunEditorOptions): Promise<void>;
 }
-declare class AppEventsAccessor extends ElementInstanceListAccessor<AppEvent, FindAppEventsQuery> {
+
+declare class FieldMappingsAccessor extends ElementListAccessor<FieldMapping, FindFieldMappingsQuery, CreateFieldMappingRequest> {
     constructor(client: IntegrationAppApiClient);
 }
-
-interface AppEventType extends WorkspaceElement {
-    revision: string;
-    archivedAt?: string;
-    subscribeRequest?: HttpRequestSpec;
-    example?: any;
-    schema?: DataSchema;
-    globalWebhookUri: string;
-    userIdFormula?: any;
+declare class FieldMappingAccessor extends ElementAccessor<FieldMapping, UpdateFieldMappingRequest, FieldMappingSelector> {
+    constructor(client: IntegrationAppApiClient, selector: string | FieldMappingSelector);
+    getAppSchema(): Promise<any>;
+    apply(integrationKeys: string[]): Promise<FieldMapping[]>;
+    setup(): Promise<any>;
+    reset(): Promise<any>;
 }
-interface AppEventSubscription extends WorkspaceElement {
-    revision: string;
-    appEventTypeId: string;
-    appEventType?: AppEventType;
-    userId: string;
-    user?: User;
-    instanceKey?: string;
-    isSubscribed: boolean;
-    schema?: DataSchema;
-    webhookUri: string;
-    subscriptionRequest: HttpRequestSpec;
-    subscriptionResponse?: any;
-    archivedAt?: string;
+declare class IntegrationLevelFieldMappingAccessor extends IntegrationLevelElementAccessor<FieldMapping, UpdateFieldMappingRequest> {
+    client: IntegrationAppApiClient;
+    integrationSelector: string;
+    fieldMappingSelector: string;
+    constructor(client: IntegrationAppApiClient, integrationSelector: string, fieldMappingSelector: string);
 }
-interface AppEvent {
-    id: string;
-    name?: string;
-    userId: string;
-    user?: User;
-    appEventTypeId: string;
-    appEventType?: AppEventType;
-    appEventSubscriptionId: string;
-    appEventSubscription?: AppEventSubscription;
-    event: any;
-    datetime: string;
-    launchedFlowRunIds: string[];
+declare class IntegrationLevelFieldMappingsListAccessor extends IntegrationLevelElementsListAccessor<FieldMapping, ListFieldMappingsForIntegrationQuery, Omit<CreateFieldMappingRequest, 'integrationId'>> {
+    client: IntegrationAppApiClient;
+    integrationSelector: string;
+    constructor(client: IntegrationAppApiClient, integrationSelector: string);
 }
 
-declare class SelfAccessor {
-    private client;
-    constructor(client: IntegrationAppApiClient);
-    get(): Promise<Customer>;
-    patch(data: Partial<{
-        credentials: any;
-    }>): Promise<Customer>;
+interface OpenIntegrationUIIntegrationConfigurationOptions extends OpenConfigurationOptions {
 }
-
-type CreateDataLinkTableRequest = Omit<DataLinkTable, 'id' | 'userId'>;
-type UpdateDataLinkTableRequest = CreateDataLinkTableRequest;
-interface FindDataLinkTablesQuery extends PaginationQuery {
+declare class IntegrationsAccessor extends ElementListAccessor<Integration, FindIntegrationsQuery, CreateIntegrationRequest> {
+    constructor(client: IntegrationAppApiClient);
 }
-interface FindDataLinkTableInstancesQuery extends PaginationQuery {
-    connectionId?: string;
-    integrationId?: string;
-    dataLinkTableId?: string;
+declare class IntegrationAccessor extends ElementAccessor<Integration, UpdateIntegrationRequest> {
+    private client;
+    private integrationSelector;
+    baseUri: string;
+    constructor(client: IntegrationAppApiClient, integrationSelector: string);
+    get actions(): IntegrationLevelActionsListAccessor;
+    action(actionSelector: string): IntegrationLevelActionAccessor;
+    get flows(): IntegrationLevelFlowsListAccessor;
+    flow(flowSelector: string): IntegrationLevelFlowAccessor;
+    get dataSources(): IntegrationLevelDataSourcesListAccessor;
+    dataSource(dataSourceSelector: string): IntegrationLevelDataSourceAccessor;
+    get fieldMappings(): IntegrationLevelFieldMappingsListAccessor;
+    fieldMapping(fieldMappingSelector: string): IntegrationLevelFieldMappingAccessor;
+    setup(): Promise<Integration>;
+    getConnectorSpec(): Promise<ConnectionSpec>;
+    open({ onClose }?: OpenIntegrationUIIntegrationConfigurationOptions): Promise<void>;
+    openNewConnection({ allowMultipleConnections, name, connectorParameters, }?: OpenNewConnectionOptions): Promise<Connection>;
+    connect({ name, parameters, connectorParameters, authOptionKey, allowMultipleConnections, redirectUri, sameWindow, }?: {
+        name?: string;
+        parameters?: any;
+        connectorParameters?: any;
+        authOptionKey?: string;
+        allowMultipleConnections?: boolean;
+    } & ({
+        sameWindow: true;
+        redirectUri: string;
+    } | {
+        sameWindow?: false;
+        redirectUri?: never;
+    })): Promise<Connection | undefined>;
+    createConnection({ parameters, name }: {
+        parameters?: any;
+        name?: string;
+    }): Promise<Connection | undefined>;
+    getOperations(): Promise<OperationListItem[]>;
+    getOperation(key: string): Promise<OperationSpec>;
+    getDataCollections(): Promise<DataCollectionListItem[]>;
+    getDataCollection(key: string): Promise<DataCollectionSpec>;
 }
-interface DataLinkTableInstanceSelector extends ConnectionSelector, ElementInstanceSelector {
-    dataLinkTableId?: string;
-    dataLinkTableKey?: string;
-    instanceKey?: string;
+
+declare class ScenariosAccessor extends ElementListAccessor<Scenario, FindScenariosQuery, CreateScenarioRequest> {
+    constructor(client: IntegrationAppApiClient);
 }
-interface UpdateDataLinkTableInstanceRequest {
+declare class ScenarioAccessor extends ElementAccessor<Scenario, UpdateScenarioRequest> {
+    constructor(client: IntegrationAppApiClient, selector: string);
 }
-interface FindDataLinksInTableQuery extends PaginationQuery {
-    direction?: DataLinkDirection;
-    appRecordId?: string;
-    externalRecordId?: string;
+
+declare class ScreensAccessor extends ElementListAccessor<Screen, FindScreensQuery, CreateScreenRequest> {
+    constructor(client: IntegrationAppApiClient);
 }
-interface CreateDataLinkRequest {
-    direction?: DataLinkDirection;
-    appRecordId: string;
-    externalRecordId: string;
+declare class ScreenAccessor extends ElementAccessor<Screen, UpdateScreenRequest, ScreenSelector> {
+    constructor(client: IntegrationAppApiClient, selector: ScreenSelector | string);
 }
-interface DeleteDataLinkRequest {
-    direction?: DataLinkDirection;
-    appRecordId: string;
-    externalRecordId: string;
+
+declare class CustomersAccessor extends ElementListAccessor<Customer, FindCustomersQuery, CreateCustomerRequest> {
+    constructor(client: IntegrationAppApiClient);
 }
-interface FindDataLinksResponse extends PaginationResponse<DataLink> {
+declare class CustomerAccessor extends ElementAccessor<Customer, UpdateCustomerRequest, CustomerSelector> {
+    constructor(client: IntegrationAppApiClient, selector: CustomerSelector | string);
 }
 
-declare class DataLinkTablesAccessor extends ElementListAccessor<DataLinkTable, FindDataLinkTablesQuery, CreateDataLinkTableRequest> {
+declare class DataLinkTablesAccessor extends ElementListAccessor<BaseDataLinkTable, FindDataLinkTablesQuery, CreateDataLinkTableRequest> {
     constructor(client: IntegrationAppApiClient);
 }
-declare class DataLinkTableAccessor extends ElementAccessor<DataLinkTable, UpdateDataLinkTableRequest> {
+declare class DataLinkTableAccessor extends ElementAccessor<BaseDataLinkTable, UpdateDataLinkTableRequest> {
     constructor(client: IntegrationAppApiClient, idOrKey: string);
 }
+
 declare class DataLinkTableInstancesAccessor extends ElementInstanceListAccessor<DataLinkTableInstance, FindDataLinkTableInstancesQuery> {
     constructor(client: IntegrationAppApiClient);
 }
@@ -2312,82 +3491,35 @@ declare class DataLinkTableInstanceAccessor extends ElementInstanceAccessor<Data
     deleteLink(data: DeleteDataLinkRequest): Promise<void>;
 }
 
-declare enum DataLinkDirection {
-    IMPORT = "import",
-    EXPORT = "export",
-    BOTH = "both"
-}
-interface DataLinkTable extends WorkspaceElement {
-    archivedAt?: string;
-}
-interface DataLinkTableInstance extends WorkspaceElement {
-    dataLinkTableId?: string;
-    dataLinkTable?: DataLinkTable;
-    connectionId?: string;
-    connection?: Connection;
-    integrationId: string;
-    integration?: Integration;
-    instanceKey?: string;
-    userId: string;
-    user?: User;
-    archivedAt?: string;
+declare class AppEventTypesAccessor extends ElementListAccessor<BaseAppEventType, FindAppEventTypesQuery, CreateAppEventTypeRequest> {
+    constructor(client: IntegrationAppApiClient);
 }
-interface DataLink {
-    id: string;
-    dataLinkTableInstanceId: string;
-    externalRecordId: string;
-    appRecordId: string;
-    direction: DataLinkDirection;
+declare class AppEventTypeAccessor extends ElementAccessor<BaseAppEventType, UpdateAppEventTypeRequest> {
+    constructor(client: IntegrationAppApiClient, idOrKey: string);
 }
 
-declare enum ExternalEventSubscriptionStatus {
-    Subscribed = "subscribed",
-    Unsubscribed = "unsubscribed",
-    Error = "error"
+declare class AppEventSubscriptionsAccessor extends ElementInstanceListAccessor<AppEventSubscription, FindAppEventSubscriptionsQuery> {
+    constructor(client: IntegrationAppApiClient);
 }
-declare enum ExternalEventSubscriptionType {
-    DataRecordCreated = "data-record-created",
-    DataRecordUpdated = "data-record-updated",
-    DataRecordDeleted = "data-record-deleted",
-    ConnectorEvent = "connector-event"
+declare class AppEventSubscriptionAccessor extends ElementInstanceAccessor<AppEventSubscription, AppEventSubscriptionSelector, UpdateAppEventSubscriptionRequest, UpdateAppEventSubscriptionRequest> {
+    constructor(client: IntegrationAppApiClient, selector: string | AppEventSubscriptionSelector);
+    subscribe(): Promise<void>;
 }
-interface ExternalEventSubscriptionConfig {
-    type: ExternalEventSubscriptionType;
-    dataSource?: DataSourceUnitConfig;
-    eventKey?: string;
-    eventParameters?: any;
+
+declare class AppDataSchemasAccessor extends ElementListAccessor<BaseAppDataSchema, FindAppDataSchemasQuery, CreateAppDataSchemaRequest> {
+    constructor(client: IntegrationAppApiClient);
 }
-interface ExternalEventSubscription {
-    id: string;
-    name?: string;
-    userId: string;
-    user?: Customer;
-    connectionId: string;
-    connection?: Connection;
-    integrationId: string;
-    integration?: Integration;
-    uuid: string;
-    config?: ExternalEventSubscriptionConfig;
-    status?: ExternalEventSubscriptionStatus;
-    error?: ErrorData;
-    isRealTime?: boolean;
-    requiresPull?: boolean;
-    requiresFullSync?: boolean;
-    createdAt?: string;
-    archivedAt?: string;
-    stateData?: any;
-    nextPullEventsTimestamp?: number;
-    pullUpdatesIntervalSeconds?: number;
-    fullSyncIntervalSeconds?: number;
-    nextRefreshTimestamp?: number;
-    globalWebhookKey?: string;
-    globalWebhookEventSelector?: string;
+declare class AppDataSchemaAccessor extends ElementAccessor<BaseAppDataSchema, UpdateAppDataSchemaRequest> {
+    constructor(client: IntegrationAppApiClient, idOrKey: string);
 }
 
-interface FindExternalEventSubscriptionsQuery extends PaginationQuery {
-    userId?: string;
-    connectionId?: string;
-    integrationId?: string;
+declare class AppDataSchemaInstancesAccessor extends ElementInstanceListAccessor<AppDataSchemaInstance, FindAppDataSchemaInstancesQuery> {
+    constructor(client: IntegrationAppApiClient);
+}
+declare class AppDataSchemaInstanceAccessor extends ElementInstanceAccessor<AppDataSchemaInstance, AppDataSchemaInstanceSelector, UpdateAppDataSchemaInstanceRequest, CreateAppDataSchemaInstanceRequest> {
+    private client;
+    constructor(client: IntegrationAppApiClient, selector: string | AppDataSchemaInstanceSelector);
+    setup(): Promise<void>;
 }
 
 declare class ExternalEventSubscriptionsAccessor extends ElementInstanceListAccessor<ExternalEventSubscription, FindExternalEventSubscriptionsQuery> {
@@ -2406,88 +3538,13 @@ declare class ExternalEventSubscriptionAccessor {
     private getPath;
 }
 
-interface Scenario extends WorkspaceElement {
-    appId: string;
-    scenarioTemplateId?: string;
-    elements?: ScenarioElement[];
-    connectors?: MinimalConnector[];
-    todos?: ScenarioToDo[];
-    appliedToIntegrations?: Integration[];
-    archivedAt?: string;
-}
-type ScenarioToDo = {
-    name: string;
-    description: string;
-    isComplete: boolean;
-};
-type ScenarioElement = {
-    id: string;
-    type: IntegrationElementType;
-    element?: any;
-};
-interface FindScenariosQuery extends SearchQuery, PaginationQuery {
-}
-interface CreateScenarioRequest {
-    name: string;
-    key: string;
-    elements?: ScenarioElement[];
-    todos?: ScenarioToDo[];
-}
-interface UpdateScenarioRequest {
-    name?: string;
-    key?: string;
-    elements?: ScenarioElement[];
-    todos?: ScenarioToDo[];
-}
-
-declare class ScenariosAccessor extends ElementListAccessor<Scenario, FindScenariosQuery, CreateScenarioRequest> {
-    constructor(client: IntegrationAppApiClient);
-}
-declare class ScenarioAccessor extends ElementAccessor<Scenario, UpdateScenarioRequest> {
-    constructor(client: IntegrationAppApiClient, selector: string);
-}
-
-declare enum ScreenType {
-    Integration = "integration"
-}
-declare enum ScreenBlockType {
-    Flow = "flow",
-    FieldMapping = "field-mapping",
-    DataSource = "data-source",
-    Action = "action"
-}
-interface ScreenBlock {
-    type: ScreenBlockType;
-    [key: string]: any;
-}
-interface ScreenSelector {
-    id?: string;
-    type?: ScreenType;
-    key?: string;
-    autoCreate?: boolean;
-    connectionId?: string;
-}
-interface UpdateScreenRequest {
-    blocks?: ScreenBlock[];
-    key?: string;
-}
-interface CreateScreenRequest extends UpdateScreenRequest {
-    type: ScreenType;
-}
-interface FindScreensQuery extends PaginationQuery {
-    type?: ScreenType;
-}
-interface Screen extends Omit<WorkspaceElement, 'key'> {
-    type: ScreenType;
-    key?: string;
-    blocks: ScreenBlock[];
-}
-
-declare class ScreensAccessor extends ElementListAccessor<Screen, FindScreensQuery, CreateScreenRequest> {
+declare class SelfAccessor {
+    private client;
     constructor(client: IntegrationAppApiClient);
-}
-declare class ScreenAccessor extends ElementAccessor<Screen, UpdateScreenRequest, ScreenSelector> {
-    constructor(client: IntegrationAppApiClient, selector: ScreenSelector | string);
+    get(): Promise<Customer>;
+    patch(data: Partial<{
+        credentials: any;
+    }>): Promise<Customer>;
 }
 
 interface OpenIntegrationAppConfigurationOptions extends OpenConfigurationOptions {
@@ -2528,7 +3585,6 @@ declare class IntegrationAppClient extends IntegrationAppApiClient {
     appEventType(id: string): AppEventTypeAccessor;
     get appEventSubscriptions(): AppEventSubscriptionsAccessor;
     appEventSubscription(selector: string | AppEventSubscriptionSelector): AppEventSubscriptionAccessor;
-    get appEvents(): AppEventsAccessor;
     get flowRuns(): FlowRunsAccessor;
     flowRun(id: string): FlowRunAccessor;
     get appDataSchemas(): AppDataSchemasAccessor;