@membranehq/sdk 0.1.0

package/dist/dts/flows/schemas.d.ts

@@ -0,0 +1,240 @@
+import { z } from 'zod';
+export declare const createFlowInstanceSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodString>;
+    flowId: z.ZodOptional<z.ZodString>;
+    connectionId: z.ZodOptional<z.ZodString>;
+    integrationId: z.ZodOptional<z.ZodString>;
+    instanceKey: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodOptional<z.ZodAny>;
+    nodes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        userConfig: z.ZodOptional<z.ZodAny>;
+        config: z.ZodOptional<z.ZodAny>;
+        onError: z.ZodOptional<z.ZodEnum<["stop", "continue"]>>;
+        concurrency: z.ZodOptional<z.ZodNumber>;
+        ui: z.ZodOptional<z.ZodAny>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodOptional<z.ZodString>;
+            filter: z.ZodOptional<z.ZodAny>;
+            name: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            key?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+        }, {
+            key?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+        }>, "many">>;
+        isCustomized: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        concurrency?: number | undefined;
+        type?: string | undefined;
+        name?: string | undefined;
+        userConfig?: any;
+        config?: any;
+        onError?: "stop" | "continue" | undefined;
+        ui?: any;
+        links?: {
+            key?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+        }[] | undefined;
+        isCustomized?: boolean | undefined;
+    }, {
+        concurrency?: number | undefined;
+        type?: string | undefined;
+        name?: string | undefined;
+        userConfig?: any;
+        config?: any;
+        onError?: "stop" | "continue" | undefined;
+        ui?: any;
+        links?: {
+            key?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+        }[] | undefined;
+        isCustomized?: boolean | undefined;
+    }>>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    customized: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodBoolean>;
+        nodes: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        name?: boolean | undefined;
+        nodes?: boolean | undefined;
+    }, {
+        name?: boolean | undefined;
+        nodes?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    userId?: string | undefined;
+    integrationId?: string | undefined;
+    connectionId?: string | undefined;
+    parameters?: any;
+    flowId?: string | undefined;
+    instanceKey?: string | undefined;
+    nodes?: Record<string, {
+        concurrency?: number | undefined;
+        type?: string | undefined;
+        name?: string | undefined;
+        userConfig?: any;
+        config?: any;
+        onError?: "stop" | "continue" | undefined;
+        ui?: any;
+        links?: {
+            key?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+        }[] | undefined;
+        isCustomized?: boolean | undefined;
+    }> | undefined;
+    enabled?: boolean | undefined;
+    customized?: {
+        name?: boolean | undefined;
+        nodes?: boolean | undefined;
+    } | undefined;
+}, {
+    name?: string | undefined;
+    userId?: string | undefined;
+    integrationId?: string | undefined;
+    connectionId?: string | undefined;
+    parameters?: any;
+    flowId?: string | undefined;
+    instanceKey?: string | undefined;
+    nodes?: Record<string, {
+        concurrency?: number | undefined;
+        type?: string | undefined;
+        name?: string | undefined;
+        userConfig?: any;
+        config?: any;
+        onError?: "stop" | "continue" | undefined;
+        ui?: any;
+        links?: {
+            key?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+        }[] | undefined;
+        isCustomized?: boolean | undefined;
+    }> | undefined;
+    enabled?: boolean | undefined;
+    customized?: {
+        name?: boolean | undefined;
+        nodes?: boolean | undefined;
+    } | undefined;
+}>;
+export declare const updateFlowInstanceSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    parameters: z.ZodOptional<z.ZodAny>;
+    nodes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        userConfig: z.ZodOptional<z.ZodAny>;
+        config: z.ZodOptional<z.ZodAny>;
+        onError: z.ZodOptional<z.ZodEnum<["stop", "continue"]>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodOptional<z.ZodString>;
+            filter: z.ZodOptional<z.ZodAny>;
+            name: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            key?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+        }, {
+            key?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+        }>, "many">>;
+        concurrency: z.ZodOptional<z.ZodNumber>;
+        isCustomized: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        concurrency?: number | undefined;
+        type?: string | undefined;
+        name?: string | undefined;
+        userConfig?: any;
+        config?: any;
+        onError?: "stop" | "continue" | undefined;
+        links?: {
+            key?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+        }[] | undefined;
+        isCustomized?: boolean | undefined;
+    }, {
+        concurrency?: number | undefined;
+        type?: string | undefined;
+        name?: string | undefined;
+        userConfig?: any;
+        config?: any;
+        onError?: "stop" | "continue" | undefined;
+        links?: {
+            key?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+        }[] | undefined;
+        isCustomized?: boolean | undefined;
+    }>>>;
+    archivedAt: z.ZodOptional<z.ZodString>;
+    customized: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodBoolean>;
+        nodes: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        name?: boolean | undefined;
+        nodes?: boolean | undefined;
+    }, {
+        name?: boolean | undefined;
+        nodes?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    parameters?: any;
+    nodes?: Record<string, {
+        concurrency?: number | undefined;
+        type?: string | undefined;
+        name?: string | undefined;
+        userConfig?: any;
+        config?: any;
+        onError?: "stop" | "continue" | undefined;
+        links?: {
+            key?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+        }[] | undefined;
+        isCustomized?: boolean | undefined;
+    }> | undefined;
+    enabled?: boolean | undefined;
+    customized?: {
+        name?: boolean | undefined;
+        nodes?: boolean | undefined;
+    } | undefined;
+    archivedAt?: string | undefined;
+}, {
+    name?: string | undefined;
+    parameters?: any;
+    nodes?: Record<string, {
+        concurrency?: number | undefined;
+        type?: string | undefined;
+        name?: string | undefined;
+        userConfig?: any;
+        config?: any;
+        onError?: "stop" | "continue" | undefined;
+        links?: {
+            key?: string | undefined;
+            name?: string | undefined;
+            filter?: any;
+        }[] | undefined;
+        isCustomized?: boolean | undefined;
+    }> | undefined;
+    enabled?: boolean | undefined;
+    customized?: {
+        name?: boolean | undefined;
+        nodes?: boolean | undefined;
+    } | undefined;
+    archivedAt?: string | undefined;
+}>;
+export type CreateFlowInstanceRequest = z.infer<typeof createFlowInstanceSchema>;
+export type UpdateFlowInstanceRequest = z.infer<typeof updateFlowInstanceSchema>;

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

@@ -0,0 +1,77 @@
+import { Connection } from '../connections';
+import { DataSchema } from '../data-schema';
+import { ErrorData } from '../errors';
+import { IntegrationElementInstance } from '../integration-elements';
+import { AppliedToIntegrations, Integration } from '../integrations';
+import { User } from '../users';
+import { WorkspaceElement, WorkspaceElementState } from '../workspace-elements';
+export interface FlowNode {
+    type?: string;
+    version?: number;
+    name?: string;
+    description?: string;
+    config?: any;
+    concurrency?: number;
+    onError?: 'stop' | 'continue';
+    ui?: any;
+    inputSchema?: any;
+    outputSchema?: any;
+    outputExample?: any;
+    links?: FlowNodeLink[];
+    isCustomized?: boolean;
+}
+export 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>;
+    isDeployed?: boolean;
+}
+export interface FlowInstance extends WorkspaceElement {
+    userId: string;
+    user?: User;
+    connectionId?: string;
+    connection?: Connection;
+    flow?: Flow;
+    flowId?: string;
+    universalFlowId?: string;
+    integrationId: string;
+    integration?: Integration;
+    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[];
+}
+export declare enum FlowInstanceNodeState {
+    SETUP_FAILED = "SETUP_FAILED",
+    READY = "READY"
+}
+export interface FlowInstanceNode extends FlowNode {
+    state?: FlowInstanceNodeState;
+    errors?: ErrorData[];
+    userConfig?: any;
+    testInput?: any;
+    dependencies?: IntegrationElementInstance[];
+}
+export interface FlowNodeLink {
+    key?: string;
+    filter?: any;
+    name?: string;
+}

package/dist/dts/flows/utils.d.ts

@@ -0,0 +1,16 @@
+import { FlowNodeSpec } from './nodes';
+import { IntegrationElementInstance, IntegrationElementType } from '../integration-elements';
+import { Flow, FlowInstance, FlowInstanceNode, FlowNode } from '.';
+export declare function getFlowNode(flow: Flow | FlowInstance, nodeKey: string): FlowNode;
+export declare function getFlowNodeTitle(flow: Flow | FlowInstance, nodeKey: string): string | undefined;
+export declare function getFlowNodeDescription(flow: Flow | FlowInstance, nodeKey: string): string | undefined;
+export declare function getFlowNodeSpec(node: FlowNode): FlowNodeSpec;
+export declare function getFlowInstanceNodeDependency({ dependencies }: Omit<FlowInstanceNode, 'errors'>, type: IntegrationElementType): IntegrationElementInstance | undefined;
+export declare function getRootNodeKeys({ nodes }: {
+    nodes?: Record<string, FlowNode>;
+}): string[];
+export declare function getChildNodeKeys(flow: Flow | FlowInstance, nodeKey: string): string[];
+export declare function getDownstreamNodeKeys(flow: Flow | FlowInstance, nodeKey: string): string[];
+export declare function getParentNodeKeys(flow: Flow | FlowInstance, nodeKey: string): string[];
+export declare function getUpstreamNodeKeys(flow: Flow | FlowInstance, nodeKey: string): string[];
+export declare function hasCycles(nodes?: Record<string, FlowNode>): boolean;

package/dist/dts/flows/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dts/http-requests.d.ts

@@ -0,0 +1,37 @@
+export declare enum HttpRequestMethod {
+    GET = "GET",
+    POST = "POST",
+    PATCH = "PATCH",
+    PUT = "PUT",
+    DELETE = "DELETE"
+}
+export interface HttpRequestSpec {
+    method?: HttpRequestMethod;
+    uri: any;
+    headers?: Record<string, any>;
+    query?: Record<string, any>;
+    body?: any;
+}
+export declare const HTTP_REQUEST_SCHEMA: {
+    type: string;
+    properties: {
+        uri: {
+            type: string;
+        };
+        method: {
+            type: string;
+            enum: string[];
+        };
+        body: {};
+        query: {
+            type: string;
+            section: boolean;
+            additionalProperties: boolean;
+        };
+        headers: {
+            type: string;
+            section: boolean;
+            additionalProperties: boolean;
+        };
+    };
+};

package/dist/dts/iframe.d.ts

@@ -0,0 +1,11 @@
+export declare const POPUP_ELEMENT_ID = "__integration-app-popup";
+export interface OpenConfigurationOptions {
+    onClose?: () => void;
+    showPoweredBy?: boolean;
+}
+export type OpenIframeOptions = OpenConfigurationOptions & {
+    [key: string]: (...args: any[]) => void;
+};
+export declare function openIframe(uri: string, callbacks?: Omit<OpenIframeOptions, 'showPoweredBy'>, { mountTargetSelector }?: {
+    mountTargetSelector?: string;
+}): Promise<void>;

package/dist/dts/index.d.ts

@@ -0,0 +1,41 @@
+export * from './errors';
+export * from './workspace-elements';
+export * from './workspace-elements-catalog';
+export * from './accessors';
+export * from './actions';
+export * from './app-data-schemas';
+export * from './app-events';
+export * from './auth';
+export * from './connections';
+export * from './connector-copilot';
+export * from './connectors';
+export * from './data-builder';
+export * from './data-collections';
+export * from './data-filter';
+export * from './data-form';
+export * from './data-links';
+export * from './data-schema';
+export * from './data-sources';
+export * from './date-time';
+export * from './entity-repository';
+export * from './external-events';
+export * from './field-mappings';
+export * from './flow-runs';
+export * from './flows';
+export * from './http-requests';
+export * from './integration-elements';
+export * from './integrations';
+export * from './logging';
+export * from './screens';
+export * from './udm';
+export * from './usage';
+export * from './users';
+export * from './scenarios';
+export * from './variables';
+export * from './workspaces';
+export * from './apps';
+export * from './workspace-updates';
+export * from './orgs';
+export * from './webhooks';
+export * from './alerts';
+export { IntegrationAppClient } from './client';

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

@@ -0,0 +1,2 @@
+import { IntegrationAppClient } from './client';
+export default IntegrationAppClient;

package/dist/dts/integration-elements/common.d.ts

@@ -0,0 +1,3 @@
+export type InstanceKeyQuery = {
+    instanceKey?: string;
+};

package/dist/dts/integration-elements/connection-level-element.accessor.d.ts

@@ -0,0 +1,29 @@
+import { IntegrationAppApiClient } from '../api-client';
+import { PaginationResponse } from '../entity-repository';
+export 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>;
+}
+export 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[]>>;
+}

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

@@ -0,0 +1,74 @@
+import { Connection } from '../connections';
+import { ErrorData } from '../errors';
+import { Integration } from '../integrations';
+import { Customer } from '../users';
+export declare enum IntegrationElementLevel {
+    UNIVERSAL = "universal",
+    CONNECTOR = "connector",
+    CONNECTION = "connection"
+}
+export 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"
+}
+export interface ElementTemplateFields {
+    id: string;
+    key: string;
+    name: string;
+    revision: string;
+    integrationId?: string;
+    integration?: Integration;
+    parentId?: string;
+    parentRevision?: string;
+    isCustomized?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+    archivedAt?: string;
+}
+export interface ElementInstanceFields {
+    id: string;
+    name: string;
+    revision: string;
+    parentId?: string;
+    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;
+}
+export interface IntegrationElement {
+    type: IntegrationElementType;
+    key?: string;
+    id?: string;
+    config?: any;
+}
+export interface IntegrationElementInstance {
+    type: IntegrationElementType;
+    instanceId?: string;
+    data?: any;
+}
+export interface IntegrationElementInstanceDependency {
+    fromType: IntegrationElementType;
+    fromInstanceId: string;
+    toType: IntegrationElementType;
+    toInstanceId: string;
+    data?: any;
+}

package/dist/dts/integration-elements/integration-level-element.accessor.d.ts

@@ -0,0 +1,25 @@
+import { IntegrationAppApiClient } from '../api-client';
+import { PaginationResponse } from '../entity-repository';
+export 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>;
+}
+export 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>;
+}

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

@@ -0,0 +1,58 @@
+import { ElementAccessor, ElementListAccessor } from '../accessors';
+import { IntegrationAppApiClient } from '../api-client';
+import { Connection, ConnectionSpec } from '../connections';
+import { DataLocationListItem, DataLocationSpec, OperationListItem, OperationSpec } from '../connectors';
+import { OpenConfigurationOptions } from '../iframe';
+import { CreateIntegrationRequest, UpdateIntegrationRequest } from './api';
+import { IntegrationLevelActionAccessor, IntegrationLevelActionsListAccessor } from '../actions';
+import { IntegrationLevelDataSourceAccessor, IntegrationLevelDataSourcesListAccessor } from '../data-sources';
+import { IntegrationLevelFieldMappingAccessor, IntegrationLevelFieldMappingsListAccessor } from '../field-mappings';
+import { IntegrationLevelFlowAccessor, IntegrationLevelFlowsListAccessor } from '../flows';
+import { FindIntegrationsQuery, Integration, OpenNewConnectionOptions } from '.';
+interface OpenIntegrationUIIntegrationConfigurationOptions extends OpenConfigurationOptions {
+}
+export declare class IntegrationsAccessor extends ElementListAccessor<Integration, FindIntegrationsQuery, CreateIntegrationRequest> {
+    constructor(client: IntegrationAppApiClient);
+}
+export 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 }?: OpenNewConnectionOptions): Promise<Connection>;
+    connect({ name, parameters, authOptionKey, allowMultipleConnections, redirectUri, sameWindow, }?: {
+        name?: string;
+        parameters?: 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>;
+}
+export {};

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

@@ -0,0 +1,23 @@
+import { PaginationQuery, PaginationResponse, SearchQuery } from '../entity-repository';
+import { OpenConfigurationOptions } from '../iframe';
+import { Integration } from './types';
+export interface CreateIntegrationRequest {
+    name?: string;
+    key: string;
+    baseUri: string;
+    logoUri: string;
+}
+export interface UpdateIntegrationRequest {
+    name?: string;
+    key?: string;
+    baseUri?: string;
+    logoUri?: string;
+}
+export interface FindIntegrationsQuery extends PaginationQuery, SearchQuery {
+}
+export interface FindIntegrationsResponse extends PaginationResponse<Integration> {
+}
+export interface OpenNewConnectionOptions extends OpenConfigurationOptions {
+    allowMultipleConnections?: boolean;
+    name?: string;
+}

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

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