@integration-app/react 0.1.25 → 0.2.0

package/dist/index.module.d.ts

@@ -0,0 +1,291 @@
+import * as _integration_app_sdk from '@integration-app/sdk';
+import { IntegrationAppClient, ConnectionSpec, Integration, IntegrationAccessor, FindIntegrationsQuery, Connection, ConnectionAccessor, FindConnectionsQuery, FieldMapping, FieldMappingAccessor, FindFieldMappingsQuery, FieldMappingInstanceSelector, IFieldMappingInstance, FieldMappingInstanceAccessor, OpenFieldMappingInstanceConfigurationOptions, FindFieldMappingInstancesQuery, DataSource, DataSourceAccessor, FindDataSourcesQuery, DataSourceInstanceSelector, DataSourceInstance, DataSourceInstanceAccessor, OpenDataSourceConfigurationOptions, DataCollectionFindRequest, DataCollectionCreateRequest, DataCollectionUpdateRequest, DataCollectionSpec, FindDataSourceEventsQuery, DataSourceEvent, FindAppEventsQuery, AppEvent, AppEventType, AppEventTypeAccessor, FindAppEventTypesQuery, AppEventSubscriptionSelector, AppEventSubscription, AppEventSubscriptionAccessor, FindAppEventSubscriptionsQuery, Flow, FlowAccessor, FindFlowsRequest, FlowInstanceSelector, FlowInstance, FlowInstanceAccessor, FindFlowInstancesQuery, FlowRun, FlowRunAccessor, FindFlowRunsRequest } from '@integration-app/sdk';
+export { DataForm } from '@integration-app/sdk';
+import { ReactNode } from 'react';
+
+interface IntegrationAppProviderProps {
+    token: string;
+    apiUri?: string;
+    uiUri?: string;
+    children: ReactNode;
+}
+declare const IntegrationAppProvider: ({ token, apiUri, uiUri, children, }: IntegrationAppProviderProps) => JSX.Element;
+declare function useIntegrationApp(): IntegrationAppClient;
+
+declare function useConnectorSpec(integrationKey: string): {
+    data: ConnectionSpec;
+    loading: boolean;
+    error: Error;
+};
+
+declare function useIntegration(idOrKey: string): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.CreateIntegrationRequest) => Promise<Integration>;
+    patch: (data: _integration_app_sdk.UpdateIntegrationRequest) => Promise<Integration>;
+    put: (data: _integration_app_sdk.CreateIntegrationRequest) => Promise<Integration>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: IntegrationAccessor;
+    integration: Integration;
+};
+
+declare function useIntegrations(query?: FindIntegrationsQuery): {
+    items: Integration[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useConnection(id: string): {
+    loading: boolean;
+    error?: Error;
+    create: (data: Partial<Connection>) => Promise<Connection>;
+    patch: (data: Partial<Connection>) => Promise<Connection>;
+    put: (data: Partial<Connection>) => Promise<Connection>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: ConnectionAccessor;
+    connection: Connection;
+};
+
+declare function useConnections(query?: FindConnectionsQuery): {
+    items: Connection[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useFieldMapping(idOrKey: string): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.CreateFieldMappingRequest) => Promise<FieldMapping>;
+    patch: (data: Partial<_integration_app_sdk.CreateFieldMappingRequest>) => Promise<FieldMapping>;
+    put: (data: _integration_app_sdk.CreateFieldMappingRequest) => Promise<FieldMapping>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: FieldMappingAccessor;
+    fieldMapping: FieldMapping;
+};
+
+declare function useFieldMappings(query?: FindFieldMappingsQuery): {
+    items: FieldMapping[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useFieldMappingInstance(selector: FieldMappingInstanceSelector | {
+    id: string;
+}): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.CreateFieldMappingInstanceRequest) => Promise<IFieldMappingInstance>;
+    patch: (data: _integration_app_sdk.UpdateFieldMappingInstanceRequest) => Promise<IFieldMappingInstance>;
+    put: (data: _integration_app_sdk.CreateFieldMappingInstanceRequest) => Promise<IFieldMappingInstance>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: FieldMappingInstanceAccessor;
+    fieldMappingInstance: IFieldMappingInstance;
+    setup: () => Promise<void>;
+    reset: () => Promise<void>;
+    openConfiguration: (options?: OpenFieldMappingInstanceConfigurationOptions) => Promise<void>;
+};
+
+declare function useFieldMappingInstances(query?: FindFieldMappingInstancesQuery): {
+    items: IFieldMappingInstance[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useDataSource(idOrKey: string): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.CreateDataSourceRequest) => Promise<DataSource>;
+    patch: (data: Partial<_integration_app_sdk.CreateDataSourceRequest>) => Promise<DataSource>;
+    put: (data: _integration_app_sdk.CreateDataSourceRequest) => Promise<DataSource>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: DataSourceAccessor;
+    dataSource: DataSource;
+};
+
+declare function useDataSources(query?: FindDataSourcesQuery): {
+    items: DataSource[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useDataSourceInstance(selector: DataSourceInstanceSelector | {
+    id: string;
+}): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.CreateDataSourceInstanceRequest) => Promise<DataSourceInstance>;
+    patch: (data: _integration_app_sdk.UpdateDataSourceInstanceRequest) => Promise<DataSourceInstance>;
+    put: (data: _integration_app_sdk.CreateDataSourceInstanceRequest) => Promise<DataSourceInstance>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: DataSourceInstanceAccessor;
+    dataSourceInstance: DataSourceInstance;
+    setup: () => Promise<void>;
+    subscribe: (eventType: any) => Promise<void>;
+    resubscribe: (eventType: any) => Promise<void>;
+    unsubscribe: (eventType: any) => Promise<void>;
+    pullUpdates: () => Promise<void>;
+    fullSync: () => Promise<void>;
+    reset: () => Promise<void>;
+    openConfiguration: (options?: OpenDataSourceConfigurationOptions) => Promise<void>;
+    findRecords: (request?: DataCollectionFindRequest) => Promise<_integration_app_sdk.DataCollectionFindResponse>;
+    findRecordById: (id: string) => Promise<_integration_app_sdk.DataCollectionFindByIdResponse>;
+    createRecord: (request?: DataCollectionCreateRequest) => Promise<_integration_app_sdk.DataCollectionCreateResponse>;
+    updateRecord: (request?: DataCollectionUpdateRequest) => Promise<_integration_app_sdk.DataCollectionUpdateResponse>;
+    deleteRecord: (id?: string) => Promise<_integration_app_sdk.DataCollectionDeleteResponse>;
+    unifiedFieldsToNative: (unifiedFields: any) => Promise<any>;
+};
+
+declare function useDataSourceInstanceCollection(dataSourceInstance: DataSourceInstance): {
+    loading: boolean;
+    error: Error;
+    refresh: () => void;
+    collection: DataCollectionSpec;
+};
+
+declare function useDataSourceInstanceLocations(dataSourceInstance: DataSourceInstance, args?: {
+    path?: string;
+    cursor?: string;
+}): {
+    loading: boolean;
+    error: Error;
+    refresh: () => void;
+    locations: _integration_app_sdk.DataLocation[];
+};
+
+declare function useDataSourceEvents(query?: FindDataSourceEventsQuery): {
+    items: DataSourceEvent[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useAppEvents(query?: FindAppEventsQuery): {
+    items: AppEvent[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useAppEventType(idOrKey: string): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.CreateAppEventTypeRequest) => Promise<AppEventType>;
+    patch: (data: _integration_app_sdk.CreateAppEventTypeRequest) => Promise<AppEventType>;
+    put: (data: _integration_app_sdk.CreateAppEventTypeRequest) => Promise<AppEventType>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: AppEventTypeAccessor;
+    appEventType: AppEventType;
+};
+
+declare function useAppEventTypes(query?: FindAppEventTypesQuery): {
+    items: AppEventType[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useAppEventSubscription(selector: AppEventSubscriptionSelector | {
+    id: string;
+}): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.IAppEventSubscriptionUpdate) => Promise<AppEventSubscription>;
+    patch: (data: _integration_app_sdk.IAppEventSubscriptionUpdate) => Promise<AppEventSubscription>;
+    put: (data: _integration_app_sdk.IAppEventSubscriptionUpdate) => Promise<AppEventSubscription>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: AppEventSubscriptionAccessor;
+    appEventSubscription: AppEventSubscription;
+};
+
+declare function useAppEventSubscriptions(query?: FindAppEventSubscriptionsQuery): {
+    items: AppEventSubscription[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useFlow(idOrKey: string): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.CreateFlowRequest) => Promise<Flow>;
+    patch: (data: _integration_app_sdk.UpdateFlowRequest) => Promise<Flow>;
+    put: (data: _integration_app_sdk.CreateFlowRequest) => Promise<Flow>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: FlowAccessor;
+    flow: Flow;
+};
+
+declare function useFlows(query?: FindFlowsRequest): {
+    items: Flow[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useFlowInstance(props: FlowInstanceSelector | {
+    id: string;
+}): {
+    loading: boolean;
+    error?: Error;
+    create: (data: _integration_app_sdk.CreateFlowInstanceRequest) => Promise<FlowInstance>;
+    patch: (data: _integration_app_sdk.UpdateFlowInstanceRequest) => Promise<FlowInstance>;
+    put: (data: _integration_app_sdk.CreateFlowInstanceRequest) => Promise<FlowInstance>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: FlowInstanceAccessor;
+    flowInstance: FlowInstance;
+};
+
+declare function useFlowInstances(query?: FindFlowInstancesQuery): {
+    items: FlowInstance[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+declare function useFlowRun(id: string): {
+    loading: boolean;
+    error?: Error;
+    create: (data: Partial<FlowRun>) => Promise<FlowRun>;
+    patch: (data: Partial<FlowRun>) => Promise<FlowRun>;
+    put: (data: Partial<FlowRun>) => Promise<FlowRun>;
+    archive: () => Promise<void>;
+    refresh: () => void;
+    accessor: FlowRunAccessor;
+    flowRun: FlowRun;
+};
+
+declare function useFlowRuns(query?: FindFlowRunsRequest): {
+    items: FlowRun[];
+    loading: boolean;
+    error?: Error;
+    refresh(): Promise<void>;
+    loadMore(): Promise<void>;
+};
+
+export { IntegrationAppProvider, useAppEventSubscription, useAppEventSubscriptions, useAppEventType, useAppEventTypes, useAppEvents, useConnection, useConnections, useConnectorSpec, useDataSource, useDataSourceInstanceCollection as useDataSourceCollection, useDataSourceEvents, useDataSourceInstance, useDataSourceInstanceLocations as useDataSourceLocations, useDataSources, useFieldMapping, useFieldMappingInstance, useFieldMappingInstances, useFieldMappings, useFlow, useFlowInstance, useFlowInstances, useFlowRun, useFlowRuns, useFlows, useIntegration, useIntegrationApp, useIntegrations };

package/dist/index.module.mjs

@@ -0,0 +1,379 @@
+import { jsx } from 'react/jsx-runtime';
+import { IntegrationAppClient } from '@integration-app/sdk';
+export { DataForm } from '@integration-app/sdk';
+import { createContext, useMemo, useContext, useState, useEffect, useRef } from 'react';
+
+const IntegrationAppContext = createContext(null);
+IntegrationAppContext.displayName = 'IntegrationAppClientContext';
+const IntegrationAppProvider = ({ token, apiUri = null, uiUri = null, children, }) => {
+    const client = useMemo(() => new IntegrationAppClient({
+        token,
+        apiUri,
+        uiUri,
+    }), [token, apiUri, uiUri]);
+    return (jsx(IntegrationAppContext.Provider, { value: client, children: children }));
+};
+function useIntegrationApp() {
+    return useContext(IntegrationAppContext);
+}
+
+function useConnectorSpec(integrationKey) {
+    const integrationApp = useIntegrationApp();
+    const [data, setData] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        if (!integrationApp) {
+            return;
+        }
+        integrationApp
+            .integration(integrationKey)
+            .getConnectorSpec()
+            .then(setData)
+            .catch(setError)
+            .finally(() => setLoading(false));
+    }, [integrationApp, integrationKey]);
+    return { data, loading, error };
+}
+
+function useElement(props, accessorGenerator) {
+    const integrationApp = useIntegrationApp();
+    const [data, setData] = useState();
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const [refreshCounter, setRefreshCounter] = useState(0);
+    const selector = (props === null || props === void 0 ? void 0 : props.id)
+        ? props.id
+        : props;
+    const accessor = integrationApp
+        ? accessorGenerator(integrationApp)(selector)
+        : null;
+    useEffect(() => {
+        setLoading(true);
+        setError(null);
+        if (integrationApp) {
+            accessor
+                .get()
+                .then(setData)
+                .catch(setError)
+                .finally(() => setLoading(false));
+        }
+        else {
+            setError(new Error('IntegrationApp not found. Was this component wrapped in <IntegrationAppProvider>?'));
+        }
+    }, [integrationApp, JSON.stringify(props), refreshCounter]);
+    async function create(createData) {
+        if (data !== undefined) {
+            setData({
+                ...data,
+                ...createData,
+            });
+        }
+        return accessorGenerator(integrationApp)(selector).create(createData);
+    }
+    function refresh() {
+        setRefreshCounter(refreshCounter + 1);
+    }
+    async function patch(patch) {
+        if (typeof patch === 'object') {
+            setData({
+                ...data,
+                ...(patch !== null && patch !== void 0 ? patch : {}),
+            });
+            return accessorGenerator(integrationApp)(selector).patch(patch);
+        }
+        else {
+            return data;
+        }
+    }
+    async function put(putData) {
+        if (data !== undefined) {
+            setData({
+                ...data,
+                ...putData,
+            });
+        }
+        return accessorGenerator(integrationApp)(selector).put(putData);
+    }
+    async function archive() {
+        setData(null);
+        return accessorGenerator(integrationApp)(selector).archive();
+    }
+    return {
+        data,
+        create,
+        patch,
+        put,
+        archive,
+        refresh,
+        loading,
+        error,
+        accessor,
+    };
+}
+
+function useIntegration(idOrKey) {
+    const { data: integration, ...rest } = useElement(idOrKey, (integrationApp) => integrationApp.integration.bind(integrationApp));
+    return { integration, ...rest };
+}
+
+function useElements(initialQuery, accessorGenerator) {
+    const integrationApp = useIntegrationApp();
+    const refreshId = useRef(0);
+    const [items, setItems] = useState([]);
+    const [nextCursor, setNextCursor] = useState(undefined);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    async function loadMore() {
+        const startingRefreshId = refreshId.current;
+        const isFirstPage = !nextCursor;
+        function setStateIfCurrentRefresh(stateSetter, valueGetter) {
+            stateSetter((value) => startingRefreshId === refreshId.current ? valueGetter(value) : value);
+        }
+        setStateIfCurrentRefresh(setError, () => null);
+        setStateIfCurrentRefresh(setLoading, () => true);
+        const queryParams = {
+            ...initialQuery,
+        };
+        if (nextCursor)
+            queryParams.cursor = nextCursor;
+        try {
+            const data = await accessorGenerator(integrationApp).find(queryParams);
+            setStateIfCurrentRefresh(setNextCursor, () => data.cursor);
+            setStateIfCurrentRefresh(setItems, (items) => isFirstPage ? data.items : [...items, ...data.items]);
+        }
+        catch (e) {
+            setStateIfCurrentRefresh(setError, () => e);
+        }
+        finally {
+            setStateIfCurrentRefresh(setLoading, () => false);
+        }
+    }
+    useEffect(() => {
+        if (!integrationApp) {
+            setError(new Error('IntegrationApp not found. Was this component wrapped in <IntegrationAppProvider>?'));
+            return;
+        }
+        refresh();
+    }, [integrationApp, JSON.stringify(initialQuery)]);
+    async function refresh() {
+        refreshId.current += 1;
+        setNextCursor(undefined);
+        await loadMore();
+    }
+    return {
+        items,
+        refresh,
+        loadMore,
+        loading,
+        error,
+    };
+}
+
+function useIntegrations(query) {
+    const { ...rest } = useElements(query, (integrationApp) => integrationApp.integrations);
+    return {
+        ...rest,
+    };
+}
+
+function useConnection(id) {
+    const { data: connection, ...rest } = useElement(id, (integrationApp) => integrationApp.connection.bind(integrationApp));
+    return { connection, ...rest };
+}
+
+function useConnections(query) {
+    const { ...rest } = useElements(query, (integrationApp) => integrationApp.connections);
+    return {
+        ...rest,
+    };
+}
+
+function useFieldMapping(idOrKey) {
+    const { data: fieldMapping, ...rest } = useElement(idOrKey, (integrationApp) => integrationApp.fieldMapping.bind(integrationApp));
+    return { fieldMapping, ...rest };
+}
+
+function useFieldMappings(query) {
+    const { ...rest } = useElements(query, (integrationApp) => integrationApp.fieldMappings);
+    return {
+        ...rest,
+    };
+}
+
+function useFieldMappingInstance(selector) {
+    const { data: fieldMappingInstance, ...rest } = useElement(selector, (integrationApp) => integrationApp.fieldMappingInstance.bind(integrationApp));
+    const accessor = rest.accessor;
+    return {
+        fieldMappingInstance,
+        setup: () => accessor.setup(),
+        reset: () => accessor.reset(),
+        openConfiguration: (options) => accessor.openConfiguration(options),
+        ...rest,
+    };
+}
+
+function useFieldMappingInstances(query) {
+    const { ...rest } = useElements(query, (integrationApp) => integrationApp.fieldMappingInstances);
+    return {
+        ...rest,
+    };
+}
+
+function useDataSource(idOrKey) {
+    const { data: dataSource, ...rest } = useElement(idOrKey, (integrationApp) => integrationApp.dataSource.bind(integrationApp));
+    return { dataSource, ...rest };
+}
+
+function useDataSources(query) {
+    const { ...rest } = useElements(query, (integrationApp) => integrationApp.dataSources);
+    return {
+        ...rest,
+    };
+}
+
+function useDataSourceInstance(selector) {
+    const { data: dataSourceInstance, ...rest } = useElement(selector, (integrationApp) => integrationApp.dataSourceInstance.bind(integrationApp));
+    const accessor = rest.accessor;
+    return {
+        dataSourceInstance,
+        setup: () => accessor.setup(),
+        subscribe: (eventType) => accessor.subscribe(eventType),
+        resubscribe: (eventType) => accessor.resubscribe(eventType),
+        unsubscribe: (eventType) => accessor.unsubscribe(eventType),
+        pullUpdates: () => accessor.pullUpdates(),
+        fullSync: () => accessor.fullSync(),
+        reset: () => accessor.reset(),
+        openConfiguration: (options) => accessor.openConfiguration(options),
+        findRecords: (request) => accessor.findRecords(request),
+        findRecordById: (id) => accessor.findRecordById(id),
+        createRecord: (request) => accessor.createRecord(request),
+        updateRecord: (request) => accessor.updateRecord(request),
+        deleteRecord: (id) => accessor.deleteRecord(id),
+        unifiedFieldsToNative: (unifiedFields) => accessor.unifiedFieldsToNative(unifiedFields),
+        ...rest,
+    };
+}
+
+function useGetter(key, getter) {
+    const integrationApp = useIntegrationApp();
+    const [data, setData] = useState();
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const [refreshCounter, setRefreshCounter] = useState(0);
+    function refresh() {
+        setRefreshCounter(refreshCounter + 1);
+    }
+    useEffect(() => {
+        if (key !== undefined) {
+            setLoading(true);
+            setError(null);
+            if (integrationApp) {
+                getter()
+                    .then(setData)
+                    .catch(setError)
+                    .finally(() => setLoading(false));
+            }
+            else {
+                setError(new Error('IntegrationApp not found. Was this component wrapped in <IntegrationAppProvider>?'));
+            }
+        }
+    }, [integrationApp, key, refreshCounter]);
+    return { data, loading, error, refresh };
+}
+
+function useDataSourceInstanceCollection(dataSourceInstance) {
+    const integrationApp = useIntegrationApp();
+    const { data: collection, ...rest } = useGetter(dataSourceInstance === null || dataSourceInstance === void 0 ? void 0 : dataSourceInstance.id, () => integrationApp.dataSourceInstance(dataSourceInstance.id).getCollection());
+    return {
+        collection,
+        ...rest,
+    };
+}
+
+function useDataSourceInstanceLocations(dataSourceInstance, args) {
+    var _a;
+    const integrationApp = useIntegrationApp();
+    const { data, ...rest } = useGetter(dataSourceInstance
+        ? `${dataSourceInstance.id}/${JSON.stringify(args)}`
+        : undefined, () => integrationApp
+        .dataSourceInstance(dataSourceInstance.id)
+        .getLocations(args));
+    return {
+        locations: (_a = data === null || data === void 0 ? void 0 : data.locations) !== null && _a !== void 0 ? _a : [],
+        ...rest,
+    };
+}
+
+function useDataSourceEvents(query) {
+    const { ...rest } = useElements(query, (integrationApp) => integrationApp.dataSourceEvents);
+    return {
+        ...rest,
+    };
+}
+
+function useAppEvents(query) {
+    const { ...rest } = useElements(query, (integrationApp) => integrationApp.appEvents);
+    return {
+        ...rest,
+    };
+}
+
+function useAppEventType(idOrKey) {
+    const { data: appEventType, ...rest } = useElement(idOrKey, (integrationApp) => integrationApp.appEventType.bind(integrationApp));
+    return { appEventType, ...rest };
+}
+
+function useAppEventTypes(query) {
+    const { ...rest } = useElements(query, (integrationApp) => integrationApp.appEventTypes);
+    return {
+        ...rest,
+    };
+}
+
+function useAppEventSubscription(selector) {
+    const { data: appEventSubscription, ...rest } = useElement(selector, (integrationApp) => integrationApp.appEventSubscription.bind(integrationApp));
+    return { appEventSubscription, ...rest };
+}
+
+function useAppEventSubscriptions(query) {
+    const { ...rest } = useElements(query, (integrationApp) => integrationApp.appEventSubscriptions);
+    return {
+        ...rest,
+    };
+}
+
+function useFlow(idOrKey) {
+    const { data: flow, ...rest } = useElement(idOrKey, (integrationApp) => integrationApp.flow.bind(integrationApp));
+    return { flow, ...rest };
+}
+
+function useFlows(query) {
+    const { ...rest } = useElements(query, (integrationApp) => integrationApp.flows);
+    return { ...rest };
+}
+
+function useFlowInstance(props) {
+    const { data: flowInstance, ...rest } = useElement(props, (integrationApp) => integrationApp.flowInstance.bind(integrationApp));
+    return { flowInstance, ...rest };
+}
+
+function useFlowInstances(query) {
+    const { ...rest } = useElements(query, (integrationApp) => integrationApp.flowInstances);
+    return {
+        ...rest,
+    };
+}
+
+function useFlowRun(id) {
+    const { data: flowRun, ...rest } = useElement(id, (integrationApp) => integrationApp.flowRun.bind(integrationApp));
+    return { flowRun, ...rest };
+}
+
+function useFlowRuns(query) {
+    const { ...rest } = useElements(query, (integrationApp) => integrationApp.flowRuns);
+    return { ...rest };
+}
+
+export { IntegrationAppProvider, useAppEventSubscription, useAppEventSubscriptions, useAppEventType, useAppEventTypes, useAppEvents, useConnection, useConnections, useConnectorSpec, useDataSource, useDataSourceInstanceCollection as useDataSourceCollection, useDataSourceEvents, useDataSourceInstance, useDataSourceInstanceLocations as useDataSourceLocations, useDataSources, useFieldMapping, useFieldMappingInstance, useFieldMappingInstances, useFieldMappings, useFlow, useFlowInstance, useFlowInstances, useFlowRun, useFlowRuns, useFlows, useIntegration, useIntegrationApp, useIntegrations };
+//# sourceMappingURL=index.module.mjs.map