@integration-app/react 0.2.0 → 0.3.1

package/dist/index.umd.d.ts

@@ -1,291 +1,508 @@
 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';
+import { IntegrationAppClient, ConnectionAccessor, Connection, CreateConnectionRequest, UpdateConnectionRequest, FindConnectionsQuery, ConnectionSpec, IntegrationAccessor, Integration, CreateIntegrationRequest, UpdateIntegrationRequest, FindIntegrationsQuery, FieldMappingSelector, CreateFieldMappingRequest, FieldMapping, UpdateFieldMappingRequest, FieldMappingAccessor, FieldMappingInstanceSelector, CreateFieldMappingInstanceRequest, FieldMappingInstance, UpdateFieldMappingInstanceRequest, FieldMappingInstanceAccessor, OpenFieldMappingInstanceConfigurationOptions, FindFieldMappingInstancesQuery, FindFieldMappingsQuery, DataSourceSelector, CreateDataSourceRequest, DataSource, DataSourceAccessor, FindDataSourceEventsQuery, DataSourceEvent, DataSourceInstanceSelector, CreateDataSourceInstanceRequest, DataSourceInstance, UpdateDataSourceInstanceRequest, DataSourceInstanceAccessor, OpenDataSourceConfigurationOptions, DataCollectionListRequest, DataCollectionFindRequest, DataCollectionCreateRequest, DataCollectionUpdateRequest, DataDirectoryListRequest, DataCollectionSpec, DataDirectoryListResponse, FindDataSourceInstancesQuery, FindDataSourcesQuery, AppEventSubscriptionSelector, AppEventSubscriptionAccessor, AppEventSubscription, IAppEventSubscriptionUpdate, FindAppEventSubscriptionsQuery, AppEventTypeAccessor, AppEventType, CreateAppEventTypeRequest, FindAppEventTypesQuery, FindAppEventsQuery, AppEvent, FlowSelector, CreateFlowRequest, Flow, UpdateFlowRequest, FlowAccessor, FindFlowsRequest, FlowInstanceSelector, UpdateFlowInstanceRequest, FlowInstance, FlowInstanceAccessor, OpenFlowInstanceConfigurationOptions, RunFlowOptions, FindFlowInstancesQuery, FlowRun, FindFlowRunsRequest, DataLinkTableAccessor, DataLinkTable, CreateDataLinkTableRequest, DataLinkTableInstanceSelector, CreateDataLinkTableInstanceRequest, DataLinkTableInstance, UpdateDataLinkTableInstanceRequest, DataLinkTableInstanceAccessor, FindDataLinkTableInstancesQuery, FindDataLinkTablesQuery, ActionSelector, CreateActionRequest, Action, UpdateActionRequest, ActionAccessor, ActionInstanceSelector, CreateActionInstanceRequest, ActionInstance, UpdateActionInstanceRequest, ActionInstanceAccessor, OpenActionConfigurationOptions, FindActionInstancesQuery, FindActionsQuery, ScreenSelector, ScreenAccessor, Screen, CreateScreenRequest, UpdateScreenRequest } from '@integration-app/sdk';
 export { DataForm } from '@integration-app/sdk';
 import { ReactNode } from 'react';
+import * as swr__internal from 'swr/_internal';
 
 interface IntegrationAppProviderProps {
-    token: string;
+    token?: string;
+    fetchToken?: () => Promise<string>;
+    credentials?: any;
+    fetchCredentials?: () => Promise<any>;
     apiUri?: string;
     uiUri?: string;
     children: ReactNode;
 }
-declare const IntegrationAppProvider: ({ token, apiUri, uiUri, children, }: IntegrationAppProviderProps) => JSX.Element;
+declare const IntegrationAppProvider: ({ token, fetchToken, credentials, fetchCredentials, apiUri, uiUri, children, }: IntegrationAppProviderProps) => JSX.Element;
 declare function useIntegrationApp(): IntegrationAppClient;
 
-declare function useConnectorSpec(integrationKey: string): {
-    data: ConnectionSpec;
+declare function useIntegrationAppSWR(path: string, options?: any): swr__internal.SWRResponse<any, any, any>;
+
+declare function useConnection(id: string): {
+    accessor: ConnectionAccessor;
     loading: boolean;
-    error: Error;
+    saving: boolean;
+    error: any;
+    refresh: () => Promise<Connection>;
+    refreshing: boolean;
+    create: (data: CreateConnectionRequest) => Promise<Connection>;
+    patch: (data: Partial<UpdateConnectionRequest>) => Promise<void>;
+    put: (data: UpdateConnectionRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    connection: Connection;
 };
 
-declare function useIntegration(idOrKey: string): {
+declare function useConnections(query?: FindConnectionsQuery): {
+    items: Connection[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
     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;
+    error: any;
+    connections: Connection[];
 };
 
-declare function useIntegrations(query?: FindIntegrationsQuery): {
-    items: Integration[];
+declare function useConnectorSpec(integrationIdOrKey: string): {
+    data: ConnectionSpec;
     loading: boolean;
-    error?: Error;
-    refresh(): Promise<void>;
-    loadMore(): Promise<void>;
+    error: any;
 };
 
-declare function useConnection(id: string): {
+declare function useIntegration(id: string): {
+    accessor: IntegrationAccessor;
     loading: boolean;
-    error?: Error;
-    create: (data: Partial<Connection>) => Promise<Connection>;
-    patch: (data: Partial<Connection>) => Promise<Connection>;
-    put: (data: Partial<Connection>) => Promise<Connection>;
+    saving: boolean;
+    error: any;
+    refresh: () => Promise<Integration>;
+    refreshing: boolean;
+    create: (data: CreateIntegrationRequest) => Promise<Integration>;
+    patch: (data: Partial<UpdateIntegrationRequest>) => Promise<void>;
+    put: (data: UpdateIntegrationRequest) => Promise<void>;
     archive: () => Promise<void>;
-    refresh: () => void;
-    accessor: ConnectionAccessor;
-    connection: Connection;
+    integration: Integration;
 };
 
-declare function useConnections(query?: FindConnectionsQuery): {
-    items: Connection[];
+declare function useIntegrations(query?: FindIntegrationsQuery): {
+    items: Integration[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
     loading: boolean;
-    error?: Error;
-    refresh(): Promise<void>;
-    loadMore(): Promise<void>;
+    error: any;
+    integrations: Integration[];
 };
 
-declare function useFieldMapping(idOrKey: string): {
+declare function useFieldMapping(selector: FieldMappingSelector | 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>;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateFieldMappingRequest) => Promise<FieldMapping>;
+    patch: (data: Partial<UpdateFieldMappingRequest>) => Promise<void>;
+    put: (data: UpdateFieldMappingRequest) => Promise<void>;
     archive: () => Promise<void>;
-    refresh: () => void;
-    accessor: FieldMappingAccessor;
     fieldMapping: FieldMapping;
+    apply: (integrationKeys: string[]) => Promise<FieldMapping[]>;
+    reset: () => Promise<void>;
+    refresh: () => Promise<FieldMapping>;
+    accessor: FieldMappingAccessor;
 };
 
-declare function useFieldMappings(query?: FindFieldMappingsQuery): {
-    items: FieldMapping[];
-    loading: boolean;
-    error?: Error;
-    refresh(): Promise<void>;
-    loadMore(): Promise<void>;
-};
-
-declare function useFieldMappingInstance(selector: FieldMappingInstanceSelector | {
-    id: string;
-}): {
+declare function useFieldMappingInstance(selector: string | FieldMappingInstanceSelector): {
     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>;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateFieldMappingInstanceRequest) => Promise<FieldMappingInstance>;
+    patch: (data: Partial<UpdateFieldMappingInstanceRequest>) => Promise<void>;
+    put: (data: UpdateFieldMappingInstanceRequest) => Promise<void>;
     archive: () => Promise<void>;
-    refresh: () => void;
+    fieldMappingInstance: FieldMappingInstance;
     accessor: FieldMappingInstanceAccessor;
-    fieldMappingInstance: IFieldMappingInstance;
+    refresh: () => Promise<FieldMappingInstance>;
     setup: () => Promise<void>;
     reset: () => Promise<void>;
     openConfiguration: (options?: OpenFieldMappingInstanceConfigurationOptions) => Promise<void>;
 };
 
 declare function useFieldMappingInstances(query?: FindFieldMappingInstancesQuery): {
-    items: IFieldMappingInstance[];
+    items: FieldMappingInstance[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
     loading: boolean;
-    error?: Error;
-    refresh(): Promise<void>;
-    loadMore(): Promise<void>;
+    error: any;
+    fieldMappingInstances: FieldMappingInstance[];
 };
 
-declare function useDataSource(idOrKey: string): {
+declare function useFieldMappings(query?: FindFieldMappingsQuery): {
+    items: FieldMapping[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    fieldMappings: FieldMapping[];
+};
+
+declare function useDataSource(selector: string | DataSourceSelector): {
     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>;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateDataSourceRequest) => Promise<DataSource>;
+    patch: (data: Partial<Partial<CreateDataSourceRequest>>) => Promise<void>;
+    put: (data: Partial<CreateDataSourceRequest>) => Promise<void>;
     archive: () => Promise<void>;
-    refresh: () => void;
-    accessor: DataSourceAccessor;
     dataSource: DataSource;
+    apply: (integrationKeys: string[]) => Promise<DataSource[]>;
+    reset: () => Promise<void>;
+    refresh: () => Promise<DataSource>;
+    accessor: DataSourceAccessor;
 };
 
-declare function useDataSources(query?: FindDataSourcesQuery): {
-    items: DataSource[];
+declare function useDataSourceEvents(query?: FindDataSourceEventsQuery): {
+    items: DataSourceEvent[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
     loading: boolean;
-    error?: Error;
-    refresh(): Promise<void>;
-    loadMore(): Promise<void>;
+    error: any;
+    dataSourceEvents: {
+        items: DataSourceEvent[];
+        refresh: () => Promise<void>;
+        refreshing: boolean;
+        loadMore: () => Promise<void>;
+        loadingMore: boolean;
+        loading: boolean;
+        error: any;
+    };
 };
 
-declare function useDataSourceInstance(selector: DataSourceInstanceSelector | {
-    id: string;
-}): {
+declare function useDataSourceInstance(selector: string | DataSourceInstanceSelector): {
     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>;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateDataSourceInstanceRequest) => Promise<DataSourceInstance>;
+    patch: (data: Partial<UpdateDataSourceInstanceRequest>) => Promise<void>;
+    put: (data: UpdateDataSourceInstanceRequest) => Promise<void>;
     archive: () => Promise<void>;
-    refresh: () => void;
-    accessor: DataSourceInstanceAccessor;
     dataSourceInstance: DataSourceInstance;
+    accessor: DataSourceInstanceAccessor;
+    refresh: () => Promise<DataSourceInstance>;
     setup: () => Promise<void>;
+    reset: () => 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>;
+    getSyncsList: () => Promise<_integration_app_sdk.DataSourceSync[]>;
     openConfiguration: (options?: OpenDataSourceConfigurationOptions) => Promise<void>;
+    listRecords: (request?: DataCollectionListRequest) => Promise<_integration_app_sdk.DataCollectionListResponse>;
     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>;
+    getLocations: (request: DataDirectoryListRequest & {
+        path?: string;
+    }) => Promise<_integration_app_sdk.DataDirectoryListResponse>;
+    getCollection: () => Promise<_integration_app_sdk.DataCollectionSpec>;
 };
 
 declare function useDataSourceInstanceCollection(dataSourceInstance: DataSourceInstance): {
-    loading: boolean;
-    error: Error;
-    refresh: () => void;
     collection: DataCollectionSpec;
+    refresh: () => Promise<DataCollectionSpec>;
+    error: any;
+    loading: boolean;
 };
 
 declare function useDataSourceInstanceLocations(dataSourceInstance: DataSourceInstance, args?: {
     path?: string;
     cursor?: string;
 }): {
-    loading: boolean;
-    error: Error;
-    refresh: () => void;
     locations: _integration_app_sdk.DataLocation[];
+    refresh: () => Promise<DataDirectoryListResponse>;
+    error: any;
+    loading: boolean;
 };
 
-declare function useDataSourceEvents(query?: FindDataSourceEventsQuery): {
-    items: DataSourceEvent[];
+declare function useDataSourceInstances(query?: FindDataSourceInstancesQuery): {
+    items: DataSourceInstance[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
     loading: boolean;
-    error?: Error;
-    refresh(): Promise<void>;
-    loadMore(): Promise<void>;
+    error: any;
+    dataSourceInstances: DataSourceInstance[];
 };
 
-declare function useAppEvents(query?: FindAppEventsQuery): {
-    items: AppEvent[];
+declare function useDataSources(query?: FindDataSourcesQuery): {
+    items: DataSource[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
     loading: boolean;
-    error?: Error;
-    refresh(): Promise<void>;
-    loadMore(): Promise<void>;
+    error: any;
+    dataSources: DataSource[];
 };
 
-declare function useAppEventType(idOrKey: string): {
+declare function useAppEventSubscription(selector: string | AppEventSubscriptionSelector): {
+    accessor: AppEventSubscriptionAccessor;
     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>;
+    saving: boolean;
+    error: any;
+    refresh: () => Promise<AppEventSubscription>;
+    refreshing: boolean;
+    create: (data: IAppEventSubscriptionUpdate) => Promise<AppEventSubscription>;
+    patch: (data: Partial<IAppEventSubscriptionUpdate>) => Promise<void>;
+    put: (data: IAppEventSubscriptionUpdate) => Promise<void>;
     archive: () => Promise<void>;
-    refresh: () => void;
-    accessor: AppEventTypeAccessor;
-    appEventType: AppEventType;
+    appEventSubscription: AppEventSubscription;
 };
 
-declare function useAppEventTypes(query?: FindAppEventTypesQuery): {
-    items: AppEventType[];
+declare function useAppEventSubscriptions(query?: FindAppEventSubscriptionsQuery): {
+    items: AppEventSubscription[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
     loading: boolean;
-    error?: Error;
-    refresh(): Promise<void>;
-    loadMore(): Promise<void>;
+    error: any;
+    appEventSubscriptions: AppEventSubscription[];
 };
 
-declare function useAppEventSubscription(selector: AppEventSubscriptionSelector | {
-    id: string;
-}): {
+declare function useAppEventType(id: string): {
+    accessor: AppEventTypeAccessor;
     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>;
+    saving: boolean;
+    error: any;
+    refresh: () => Promise<AppEventType>;
+    refreshing: boolean;
+    create: (data: CreateAppEventTypeRequest) => Promise<AppEventType>;
+    patch: (data: Partial<CreateAppEventTypeRequest>) => Promise<void>;
+    put: (data: CreateAppEventTypeRequest) => Promise<void>;
     archive: () => Promise<void>;
-    refresh: () => void;
-    accessor: AppEventSubscriptionAccessor;
-    appEventSubscription: AppEventSubscription;
+    appEventType: AppEventType;
 };
 
-declare function useAppEventSubscriptions(query?: FindAppEventSubscriptionsQuery): {
-    items: AppEventSubscription[];
+declare function useAppEventTypes(query?: FindAppEventTypesQuery): {
+    items: AppEventType[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    appEventTypes: AppEventType[];
+};
+
+declare function useAppEvents(query?: FindAppEventsQuery): {
+    items: AppEvent[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
     loading: boolean;
-    error?: Error;
-    refresh(): Promise<void>;
-    loadMore(): Promise<void>;
+    error: any;
+    appEvents: AppEvent[];
 };
 
-declare function useFlow(idOrKey: string): {
+declare function useFlow(selector: string | FlowSelector): {
     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>;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateFlowRequest) => Promise<Flow>;
+    patch: (data: Partial<UpdateFlowRequest>) => Promise<void>;
+    put: (data: UpdateFlowRequest) => Promise<void>;
     archive: () => Promise<void>;
-    refresh: () => void;
-    accessor: FlowAccessor;
     flow: Flow;
+    apply: (integrationKeys: string[]) => Promise<Flow[]>;
+    reset: () => Promise<Flow>;
+    refresh: () => Promise<Flow>;
+    accessor: FlowAccessor;
 };
 
 declare function useFlows(query?: FindFlowsRequest): {
     items: Flow[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
     loading: boolean;
-    error?: Error;
-    refresh(): Promise<void>;
-    loadMore(): Promise<void>;
+    error: any;
+    flows: Flow[];
 };
 
-declare function useFlowInstance(props: FlowInstanceSelector | {
-    id: string;
-}): {
+declare function useFlowInstance(selector: string | FlowInstanceSelector): {
     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>;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: UpdateFlowInstanceRequest) => Promise<FlowInstance>;
+    patch: (data: Partial<UpdateFlowInstanceRequest>) => Promise<void>;
+    put: (data: UpdateFlowInstanceRequest) => Promise<void>;
     archive: () => Promise<void>;
-    refresh: () => void;
-    accessor: FlowInstanceAccessor;
     flowInstance: FlowInstance;
+    accessor: FlowInstanceAccessor;
+    refresh: () => Promise<FlowInstance>;
+    enable: () => Promise<void>;
+    disable: () => Promise<void>;
+    reset: () => Promise<void>;
+    setup: () => Promise<void>;
+    openConfiguration: (options: OpenFlowInstanceConfigurationOptions) => Promise<void>;
+    run: (options?: RunFlowOptions) => Promise<_integration_app_sdk.FlowRun>;
+    startRun: (options?: RunFlowOptions) => Promise<_integration_app_sdk.FlowRun>;
 };
 
 declare function useFlowInstances(query?: FindFlowInstancesQuery): {
     items: FlowInstance[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
     loading: boolean;
-    error?: Error;
-    refresh(): Promise<void>;
-    loadMore(): Promise<void>;
+    error: any;
+    flowInstances: FlowInstance[];
 };
 
 declare function useFlowRun(id: string): {
+    flowRun: FlowRun;
+    error: any;
     loading: boolean;
-    error?: Error;
-    create: (data: Partial<FlowRun>) => Promise<FlowRun>;
-    patch: (data: Partial<FlowRun>) => Promise<FlowRun>;
-    put: (data: Partial<FlowRun>) => Promise<FlowRun>;
+    refresh: () => Promise<FlowRun>;
     archive: () => Promise<void>;
-    refresh: () => void;
-    accessor: FlowRunAccessor;
-    flowRun: FlowRun;
 };
 
 declare function useFlowRuns(query?: FindFlowRunsRequest): {
     items: FlowRun[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    flowRuns: FlowRun[];
+};
+
+declare function useDataLinkTable(selector: string): {
+    accessor: DataLinkTableAccessor;
     loading: boolean;
-    error?: Error;
-    refresh(): Promise<void>;
-    loadMore(): Promise<void>;
+    saving: boolean;
+    error: any;
+    refresh: () => Promise<DataLinkTable>;
+    refreshing: boolean;
+    create: (data: CreateDataLinkTableRequest) => Promise<DataLinkTable>;
+    patch: (data: Partial<CreateDataLinkTableRequest>) => Promise<void>;
+    put: (data: CreateDataLinkTableRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    dataLinkTable: DataLinkTable;
 };
 
-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 };
+declare function useDataLinkTableInstance(selector: string | DataLinkTableInstanceSelector): {
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateDataLinkTableInstanceRequest) => Promise<DataLinkTableInstance>;
+    patch: (data: Partial<UpdateDataLinkTableInstanceRequest>) => Promise<void>;
+    put: (data: UpdateDataLinkTableInstanceRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    dataLinkTableInstance: DataLinkTableInstance;
+    accessor: DataLinkTableInstanceAccessor;
+    refresh: () => Promise<DataLinkTableInstance>;
+    findLinks: (query?: _integration_app_sdk.FindDataLinksInTableQuery) => Promise<_integration_app_sdk.FindDataLinksResponse>;
+    createLink: (data: _integration_app_sdk.CreateDataLinkRequest) => Promise<void>;
+    deleteLink: (data: _integration_app_sdk.DeleteDataLinkRequest) => Promise<void>;
+};
+
+declare function useDataLinkTableInstances(query?: FindDataLinkTableInstancesQuery): {
+    items: DataLinkTableInstance[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    dataLinkTableInstances: DataLinkTableInstance[];
+};
+
+declare function useDataLinkTables(query?: FindDataLinkTablesQuery): {
+    items: DataLinkTable[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    dataLinkTables: DataLinkTable[];
+};
+
+declare function useAction(selector: ActionSelector | string): {
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateActionRequest) => Promise<Action>;
+    patch: (data: Partial<UpdateActionRequest>) => Promise<void>;
+    put: (data: UpdateActionRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    action: Action;
+    apply: (integrationKeys: string[]) => Promise<Action[]>;
+    reset: () => Promise<void>;
+    refresh: () => Promise<Action>;
+    accessor: ActionAccessor;
+};
+
+declare function useActionInstance(selector: string | ActionInstanceSelector): {
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateActionInstanceRequest) => Promise<ActionInstance>;
+    patch: (data: Partial<UpdateActionInstanceRequest>) => Promise<void>;
+    put: (data: UpdateActionInstanceRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    actionInstance: ActionInstance;
+    accessor: ActionInstanceAccessor;
+    refresh: () => Promise<ActionInstance>;
+    setup: () => Promise<void>;
+    reset: () => Promise<void>;
+    openConfiguration: (options?: OpenActionConfigurationOptions) => Promise<void>;
+    run: (input?: any) => Promise<_integration_app_sdk.ActionRunResponse>;
+};
+
+declare function useActionInstances(query?: FindActionInstancesQuery): {
+    items: ActionInstance[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    actionInstances: ActionInstance[];
+};
+
+declare function useActions(query?: FindActionsQuery): {
+    items: Action[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    actions: Action[];
+};
+
+declare function useScreen(selector: ScreenSelector | string): {
+    accessor: ScreenAccessor;
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refresh: () => Promise<Screen>;
+    refreshing: boolean;
+    create: (data: CreateScreenRequest) => Promise<Screen>;
+    patch: (data: Partial<UpdateScreenRequest>) => Promise<void>;
+    put: (data: UpdateScreenRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    screen: Screen;
+};
+
+declare function useDataCollectionSpec({ path, key, integrationId, }: {
+    path?: string;
+    key?: string;
+    integrationId: string;
+}): DataCollectionSpec;
+
+export { IntegrationAppProvider, useAction, useActionInstance, useActionInstances, useActions, useAppEventSubscription, useAppEventSubscriptions, useAppEventType, useAppEventTypes, useAppEvents, useConnection, useConnections, useConnectorSpec, useDataCollectionSpec, useDataLinkTable, useDataLinkTableInstance, useDataLinkTableInstances, useDataLinkTables, useDataSource, useDataSourceEvents, useDataSourceInstance, useDataSourceInstanceCollection, useDataSourceInstanceLocations, useDataSourceInstances, useDataSources, useFieldMapping, useFieldMappingInstance, useFieldMappingInstances, useFieldMappings, useFlow, useFlowInstance, useFlowInstances, useFlowRun, useFlowRuns, useFlows, useIntegration, useIntegrationApp, useIntegrationAppSWR, useIntegrations, useScreen };