@integration-app/react 2.0.3-beta.0 → 2.0.3-beta.1

package/dist/types/_modules/awesome-debounce-promise.d.ts

@@ -0,0 +1,2 @@
+declare const AwesomeDebouncePromise: any;
+export default AwesomeDebouncePromise;

package/dist/types/components/Integrations/IntegrationAvatar/index.d.ts

@@ -0,0 +1,6 @@
+import { Integration } from '@integration-app/sdk';
+type HTMLDivProps = React.HTMLAttributes<HTMLDivElement>;
+export declare const IntegrationAvatar: React.FC<{
+    integration: Integration;
+} & HTMLDivProps>;
+export {};

package/dist/types/components/Integrations/IntegrationItem/index.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { Integration } from '@integration-app/sdk';
+import { StrictAsChild } from '../../../utils/types';
+type HTMLButtonProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+export declare const IntegrationItem: React.ForwardRefExoticComponent<({
+    integration: Integration;
+} & HTMLButtonProps & StrictAsChild<HTMLButtonElement>) & React.RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/types/components/Integrations/IntegrationItemSkeleton.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+type HTMLDivProps = React.HTMLAttributes<HTMLDivElement>;
+export declare const IntegrationItemSkeleton: React.ForwardRefExoticComponent<Omit<HTMLDivProps, "children"> & React.RefAttributes<HTMLDivElement>>;
+export {};

package/dist/types/components/Integrations/index.d.ts

@@ -0,0 +1,3 @@
+export * from './IntegrationAvatar';
+export * from './IntegrationItem';
+export * from './IntegrationItemSkeleton';

package/dist/types/contexts/index.d.ts

@@ -0,0 +1,2 @@
+export * from './integration-app-context.js';
+export { useIntegrationApp } from './integration-app-context.js';

package/dist/types/contexts/integration-app-context.d.ts

@@ -0,0 +1,14 @@
+import { IntegrationAppClient } from '@integration-app/sdk';
+import { ReactNode } from 'react';
+interface IntegrationAppProviderProps {
+    token?: string;
+    fetchToken?: () => Promise<string>;
+    credentials?: any;
+    fetchCredentials?: () => Promise<any>;
+    apiUri?: string;
+    uiUri?: string;
+    children: ReactNode;
+}
+export declare const IntegrationAppProvider: ({ token, fetchToken, credentials, fetchCredentials, apiUri, uiUri, children, }: IntegrationAppProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare function useIntegrationApp(): IntegrationAppClient;
+export {};

package/dist/types/hooks/actions/useAction.d.ts

@@ -0,0 +1,16 @@
+import { CreateActionRequest, Action, ActionAccessor, ActionSelector, UpdateActionRequest } from '@integration-app/sdk';
+export declare function useAction(selector: ActionSelector | string | undefined): {
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateActionRequest) => Promise<Action | undefined>;
+    patch: (data: Partial<UpdateActionRequest>) => Promise<void>;
+    put: (data: UpdateActionRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    action: Action | undefined;
+    apply: (integrationKeys: string[]) => Promise<Action[] | undefined>;
+    reset: () => Promise<void>;
+    refresh: () => Promise<Action>;
+    accessor: ActionAccessor | undefined;
+};

package/dist/types/hooks/actions/useActionInstance.d.ts

@@ -0,0 +1,18 @@
+import { ActionInstanceAccessor, ActionInstanceSelector, ActionInstance, OpenActionConfigurationOptions, UpdateActionInstanceRequest, CreateActionInstanceRequest } from '@integration-app/sdk';
+export declare function useActionInstance(selector: string | ActionInstanceSelector | undefined): {
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateActionInstanceRequest) => Promise<ActionInstance | undefined>;
+    patch: (data: Partial<UpdateActionInstanceRequest>) => Promise<void>;
+    put: (data: UpdateActionInstanceRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    actionInstance: ActionInstance | undefined;
+    accessor: ActionInstanceAccessor | undefined;
+    refresh: () => Promise<ActionInstance>;
+    setup: () => Promise<void>;
+    reset: () => Promise<void>;
+    openConfiguration: (options?: OpenActionConfigurationOptions) => Promise<void | undefined>;
+    run: (input?: any) => Promise<import("@integration-app/sdk").ActionRunResponse | undefined>;
+};

package/dist/types/hooks/actions/useActionInstances.d.ts

@@ -0,0 +1,11 @@
+import { FindActionInstancesQuery, ActionInstance } from '@integration-app/sdk';
+export declare function useActionInstances(query?: FindActionInstancesQuery): {
+    items: ActionInstance[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    actionInstances: ActionInstance[];
+};

package/dist/types/hooks/actions/useActions.d.ts

@@ -0,0 +1,11 @@
+import { Action, FindActionsQuery } from '@integration-app/sdk';
+export declare function useActions(query?: FindActionsQuery): {
+    items: Action[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    actions: Action[];
+};

package/dist/types/hooks/app-data-schemas/useAppDataSchema.d.ts

@@ -0,0 +1,14 @@
+import { CreateAppDataSchemaRequest, AppDataSchema, AppDataSchemaAccessor, UpdateAppDataSchemaRequest } from '@integration-app/sdk';
+export declare function useAppDataSchema(selector: string | undefined): {
+    accessor: AppDataSchemaAccessor | undefined;
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refresh: () => Promise<AppDataSchema>;
+    refreshing: boolean;
+    create: (data: CreateAppDataSchemaRequest) => Promise<AppDataSchema | undefined>;
+    patch: (data: Partial<UpdateAppDataSchemaRequest>) => Promise<void>;
+    put: (data: UpdateAppDataSchemaRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    appDataSchema: AppDataSchema | undefined;
+};

package/dist/types/hooks/app-data-schemas/useAppDataSchemaInstance.d.ts

@@ -0,0 +1,15 @@
+import { AppDataSchemaInstanceAccessor, AppDataSchemaInstanceSelector, UpdateAppDataSchemaInstanceRequest, CreateAppDataSchemaInstanceRequest, AppDataSchemaInstance } from '@integration-app/sdk';
+export declare function useAppDataSchemaInstance(selector: string | AppDataSchemaInstanceSelector | undefined): {
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateAppDataSchemaInstanceRequest) => Promise<AppDataSchemaInstance | undefined>;
+    patch: (data: Partial<UpdateAppDataSchemaInstanceRequest>) => Promise<void>;
+    put: (data: UpdateAppDataSchemaInstanceRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    appDataSchemaInstance: AppDataSchemaInstance | undefined;
+    accessor: AppDataSchemaInstanceAccessor | undefined;
+    refresh: () => Promise<AppDataSchemaInstance>;
+    setup: () => Promise<void>;
+};

package/dist/types/hooks/app-data-schemas/useAppDataSchemaInstances.d.ts

@@ -0,0 +1,11 @@
+import { AppDataSchemaInstance, FindAppDataSchemaInstancesQuery } from '@integration-app/sdk';
+export declare function useAppDataSchemaInstances(query?: FindAppDataSchemaInstancesQuery): {
+    items: AppDataSchemaInstance[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    appDataSchemaInstances: AppDataSchemaInstance[];
+};

package/dist/types/hooks/app-data-schemas/useAppDataSchemas.d.ts

@@ -0,0 +1,11 @@
+import { AppDataSchema, FindAppDataSchemasQuery } from '@integration-app/sdk';
+export declare function useAppDataSchemas(query?: FindAppDataSchemasQuery): {
+    items: AppDataSchema[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    appDataSchemas: AppDataSchema[];
+};

package/dist/types/hooks/app-events/useAppEventSubscription.d.ts

@@ -0,0 +1,14 @@
+import { AppEventSubscription, AppEventSubscriptionAccessor, AppEventSubscriptionSelector, AppEventSubscriptionUpdateRequest } from '@integration-app/sdk';
+export declare function useAppEventSubscription(selector: string | AppEventSubscriptionSelector | undefined): {
+    accessor: AppEventSubscriptionAccessor | undefined;
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refresh: () => Promise<AppEventSubscription>;
+    refreshing: boolean;
+    create: (data: AppEventSubscriptionUpdateRequest) => Promise<AppEventSubscription | undefined>;
+    patch: (data: Partial<AppEventSubscriptionUpdateRequest>) => Promise<void>;
+    put: (data: AppEventSubscriptionUpdateRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    appEventSubscription: AppEventSubscription | undefined;
+};

package/dist/types/hooks/app-events/useAppEventSubscriptions.d.ts

@@ -0,0 +1,11 @@
+import { AppEventSubscription, FindAppEventSubscriptionsQuery } from '@integration-app/sdk';
+export declare function useAppEventSubscriptions(query?: FindAppEventSubscriptionsQuery): {
+    items: AppEventSubscription[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    appEventSubscriptions: AppEventSubscription[];
+};

package/dist/types/hooks/app-events/useAppEventType.d.ts

@@ -0,0 +1,15 @@
+import { AppEventType, CreateAppEventTypeRequest, UpdateAppEventTypeRequest } from '@integration-app/sdk';
+import { AppEventTypeAccessor } from '@integration-app/sdk';
+export declare function useAppEventType(selector: string | undefined): {
+    accessor: AppEventTypeAccessor | undefined;
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refresh: () => Promise<AppEventType>;
+    refreshing: boolean;
+    create: (data: CreateAppEventTypeRequest) => Promise<AppEventType | undefined>;
+    patch: (data: Partial<UpdateAppEventTypeRequest>) => Promise<void>;
+    put: (data: UpdateAppEventTypeRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    appEventType: AppEventType | undefined;
+};

package/dist/types/hooks/app-events/useAppEventTypes.d.ts

@@ -0,0 +1,11 @@
+import { AppEventType, FindAppEventTypesQuery } from '@integration-app/sdk';
+export declare function useAppEventTypes(query?: FindAppEventTypesQuery): {
+    items: AppEventType[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    appEventTypes: AppEventType[];
+};

package/dist/types/hooks/app-events/useAppEvents.d.ts

@@ -0,0 +1,11 @@
+import { AppEvent, FindAppEventsQuery } from '@integration-app/sdk';
+export declare function useAppEvents(query?: FindAppEventsQuery): {
+    items: AppEvent[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    appEvents: AppEvent[];
+};

package/dist/types/hooks/customers/useCustomer.d.ts

@@ -0,0 +1,14 @@
+import { Customer, CustomerSelector, UpdateCustomerRequest, CreateCustomerRequest, CustomerAccessor } from '@integration-app/sdk';
+export declare function useCustomer(selector: CustomerSelector | string | undefined): {
+    accessor: CustomerAccessor | undefined;
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refresh: () => Promise<Customer>;
+    refreshing: boolean;
+    create: (data: CreateCustomerRequest) => Promise<Customer | undefined>;
+    patch: (data: Partial<UpdateCustomerRequest>) => Promise<void>;
+    put: (data: UpdateCustomerRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    customer: Customer | undefined;
+};

package/dist/types/hooks/customers/useCustomers.d.ts

@@ -0,0 +1,11 @@
+import { Customer, FindCustomersQuery } from '@integration-app/sdk';
+export declare function useCustomers(query?: FindCustomersQuery): {
+    items: Customer[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    customers: Customer[];
+};

package/dist/types/hooks/data-collections/useDataCollectionSpec.d.ts

@@ -0,0 +1,6 @@
+import { DataCollectionSpec } from '@integration-app/sdk';
+export declare function useDataCollectionSpec({ path, key, integrationId, }: {
+    path?: string | undefined;
+    key?: string | undefined;
+    integrationId: string;
+}): DataCollectionSpec | undefined;

package/dist/types/hooks/data-form/index.d.ts

@@ -0,0 +1 @@
+export default function DataForm(): import("react/jsx-runtime").JSX.Element;

package/dist/types/hooks/data-links/useDataLinkTable.d.ts

@@ -0,0 +1,14 @@
+import { CreateDataLinkTableRequest, DataLinkTable, DataLinkTableAccessor } from '@integration-app/sdk';
+export declare function useDataLinkTable(selector: string | undefined): {
+    accessor: DataLinkTableAccessor | undefined;
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refresh: () => Promise<DataLinkTable>;
+    refreshing: boolean;
+    create: (data: CreateDataLinkTableRequest) => Promise<DataLinkTable | undefined>;
+    patch: (data: Partial<CreateDataLinkTableRequest>) => Promise<void>;
+    put: (data: CreateDataLinkTableRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    dataLinkTable: DataLinkTable | undefined;
+};

package/dist/types/hooks/data-links/useDataLinkTableInstance.d.ts

@@ -0,0 +1,17 @@
+import { DataLinkTableInstanceAccessor, DataLinkTableInstanceSelector, DataLinkTableInstance, UpdateDataLinkTableInstanceRequest, CreateDataLinkTableInstanceRequest } from '@integration-app/sdk';
+export declare function useDataLinkTableInstance(selector: string | DataLinkTableInstanceSelector | undefined): {
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateDataLinkTableInstanceRequest) => Promise<DataLinkTableInstance | undefined>;
+    patch: (data: Partial<UpdateDataLinkTableInstanceRequest>) => Promise<void>;
+    put: (data: UpdateDataLinkTableInstanceRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    dataLinkTableInstance: DataLinkTableInstance | undefined;
+    accessor: DataLinkTableInstanceAccessor | undefined;
+    refresh: () => Promise<DataLinkTableInstance>;
+    findLinks: ((query?: import("@integration-app/sdk").FindDataLinksInTableQuery | undefined) => Promise<import("@integration-app/sdk").FindDataLinksResponse>) | undefined;
+    createLink: ((data: import("@integration-app/sdk").CreateDataLinkRequest) => Promise<void>) | undefined;
+    deleteLink: ((data: import("@integration-app/sdk").DeleteDataLinkRequest) => Promise<void>) | undefined;
+};

package/dist/types/hooks/data-links/useDataLinkTableInstances.d.ts

@@ -0,0 +1,11 @@
+import { FindDataLinkTableInstancesQuery, DataLinkTableInstance } from '@integration-app/sdk';
+export declare function useDataLinkTableInstances(query?: FindDataLinkTableInstancesQuery): {
+    items: DataLinkTableInstance[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    dataLinkTableInstances: DataLinkTableInstance[];
+};

package/dist/types/hooks/data-links/useDataLinkTables.d.ts

@@ -0,0 +1,11 @@
+import { DataLinkTable, FindDataLinkTablesQuery } from '@integration-app/sdk';
+export declare function useDataLinkTables(query?: FindDataLinkTablesQuery): {
+    items: DataLinkTable[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    dataLinkTables: DataLinkTable[];
+};

package/dist/types/hooks/data-sources/useDataSource.d.ts

@@ -0,0 +1,16 @@
+import { CreateDataSourceRequest, DataSource, DataSourceAccessor, DataSourceSelector, UpdateDataSourceRequest } from '@integration-app/sdk';
+export declare function useDataSource(selector: string | DataSourceSelector | undefined): {
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateDataSourceRequest) => Promise<DataSource | undefined>;
+    patch: (data: Partial<UpdateDataSourceRequest>) => Promise<void>;
+    put: (data: UpdateDataSourceRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    dataSource: DataSource | undefined;
+    apply: (integrationKeys: string[]) => Promise<DataSource[]>;
+    reset: () => Promise<void>;
+    refresh: () => Promise<DataSource>;
+    accessor: DataSourceAccessor | undefined;
+};

package/dist/types/hooks/data-sources/useDataSourceInstance.d.ts

@@ -0,0 +1,25 @@
+import { DataCollectionCreateRequest, DataCollectionFindRequest, DataCollectionUpdateRequest, DataSourceInstanceAccessor, DataSourceInstanceSelector, OpenDataSourceConfigurationOptions, DataSourceInstance, UpdateDataSourceInstanceRequest, DataCollectionListRequest, CreateDataSourceInstanceRequest } from '@integration-app/sdk';
+export declare function useDataSourceInstance(selector: string | DataSourceInstanceSelector | undefined): {
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateDataSourceInstanceRequest) => Promise<DataSourceInstance | undefined>;
+    patch: (data: Partial<UpdateDataSourceInstanceRequest>) => Promise<void>;
+    put: (data: UpdateDataSourceInstanceRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    dataSourceInstance: DataSourceInstance | undefined;
+    accessor: DataSourceInstanceAccessor | undefined;
+    refresh: () => Promise<DataSourceInstance>;
+    setup: () => Promise<void>;
+    reset: () => Promise<void>;
+    openConfiguration: (options?: OpenDataSourceConfigurationOptions) => Promise<void | undefined>;
+    listRecords: (request?: DataCollectionListRequest) => Promise<import("@integration-app/sdk").DataCollectionListResponse | undefined>;
+    findRecords: (request?: DataCollectionFindRequest) => Promise<import("@integration-app/sdk").DataCollectionFindResponse | undefined>;
+    findRecordById: (id: string) => Promise<import("@integration-app/sdk").DataCollectionFindByIdResponse | undefined>;
+    createRecord: (request?: DataCollectionCreateRequest) => Promise<import("@integration-app/sdk").DataCollectionCreateResponse | undefined>;
+    updateRecord: (request?: DataCollectionUpdateRequest) => Promise<import("@integration-app/sdk").DataCollectionUpdateResponse | undefined>;
+    deleteRecord: (id?: string) => Promise<import("@integration-app/sdk").DataCollectionDeleteResponse | undefined>;
+    unifiedFieldsToNative: (unifiedFields: any) => Promise<any>;
+    getCollection: () => Promise<import("@integration-app/sdk").DataCollectionSpec | undefined>;
+};

package/dist/types/hooks/data-sources/useDataSourceInstanceCollection.d.ts

@@ -0,0 +1,7 @@
+import { DataCollectionSpec, DataSourceInstance } from '@integration-app/sdk';
+export declare function useDataSourceInstanceCollection(dataSourceInstance: DataSourceInstance): {
+    collection: DataCollectionSpec | undefined;
+    refresh: () => Promise<DataCollectionSpec | undefined>;
+    error: any;
+    loading: boolean;
+};

package/dist/types/hooks/data-sources/useDataSourceInstances.d.ts

@@ -0,0 +1,11 @@
+import { FindDataSourceInstancesQuery, DataSourceInstance } from '@integration-app/sdk';
+export declare function useDataSourceInstances(query?: FindDataSourceInstancesQuery): {
+    items: DataSourceInstance[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    dataSourceInstances: DataSourceInstance[];
+};

package/dist/types/hooks/data-sources/useDataSources.d.ts

@@ -0,0 +1,11 @@
+import { DataSource, FindDataSourcesQuery } from '@integration-app/sdk';
+export declare function useDataSources(query?: FindDataSourcesQuery): {
+    items: DataSource[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    dataSources: DataSource[];
+};

package/dist/types/hooks/external-events/useExternalEventSubscription.d.ts

@@ -0,0 +1,19 @@
+import { ExternalEventSubscription, ExternalEventSubscriptionAccessor } from '@integration-app/sdk';
+export declare function useExternalEventSubscription(id: string | undefined): {
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: undefined) => Promise<ExternalEventSubscription | undefined>;
+    patch: (data: undefined) => Promise<void>;
+    put: (data: undefined) => Promise<void>;
+    archive: () => Promise<void>;
+    externalEventSubscription: ExternalEventSubscription | undefined;
+    accessor: ExternalEventSubscriptionAccessor | undefined;
+    refresh: () => Promise<ExternalEventSubscription>;
+    setup: () => Promise<void>;
+    subscribe: () => Promise<void>;
+    resubscribe: () => Promise<void>;
+    unsubscribe: () => Promise<void>;
+    pullEvents: () => Promise<void>;
+};

package/dist/types/hooks/external-events/useExternalEventSubscriptions.d.ts

@@ -0,0 +1,11 @@
+import { FindExternalEventSubscriptionsQuery, ExternalEventSubscription } from '@integration-app/sdk';
+export declare function useExternalEventSubscriptions(query?: FindExternalEventSubscriptionsQuery): {
+    items: ExternalEventSubscription[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    externalEventSubscriptions: ExternalEventSubscription[];
+};

package/dist/types/hooks/field-mappings/useFieldMapping.d.ts

@@ -0,0 +1,16 @@
+import { CreateFieldMappingRequest, FieldMapping, FieldMappingAccessor, FieldMappingSelector, UpdateFieldMappingRequest } from '@integration-app/sdk';
+export declare function useFieldMapping(selector: FieldMappingSelector | string | undefined): {
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateFieldMappingRequest) => Promise<FieldMapping | undefined>;
+    patch: (data: Partial<UpdateFieldMappingRequest>) => Promise<void>;
+    put: (data: UpdateFieldMappingRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    fieldMapping: FieldMapping | undefined;
+    apply: (integrationKeys: string[]) => Promise<FieldMapping[]>;
+    reset: () => Promise<void>;
+    refresh: () => Promise<FieldMapping>;
+    accessor: FieldMappingAccessor | undefined;
+};

package/dist/types/hooks/field-mappings/useFieldMappingInstance.d.ts

@@ -0,0 +1,17 @@
+import { FieldMappingInstanceAccessor, FieldMappingInstanceSelector, FieldMappingInstance, OpenFieldMappingInstanceConfigurationOptions, UpdateFieldMappingInstanceRequest, CreateFieldMappingInstanceRequest } from '@integration-app/sdk';
+export declare function useFieldMappingInstance(selector: string | FieldMappingInstanceSelector | undefined): {
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateFieldMappingInstanceRequest) => Promise<FieldMappingInstance | undefined>;
+    patch: (data: Partial<UpdateFieldMappingInstanceRequest>) => Promise<void>;
+    put: (data: UpdateFieldMappingInstanceRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    fieldMappingInstance: FieldMappingInstance | undefined;
+    accessor: FieldMappingInstanceAccessor | undefined;
+    refresh: () => Promise<FieldMappingInstance>;
+    setup: () => Promise<void>;
+    reset: () => Promise<void>;
+    openConfiguration: (options?: OpenFieldMappingInstanceConfigurationOptions) => Promise<void | undefined>;
+};

package/dist/types/hooks/field-mappings/useFieldMappingInstances.d.ts

@@ -0,0 +1,11 @@
+import { FindFieldMappingInstancesQuery, FieldMappingInstance } from '@integration-app/sdk';
+export declare function useFieldMappingInstances(query?: FindFieldMappingInstancesQuery): {
+    items: FieldMappingInstance[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    fieldMappingInstances: FieldMappingInstance[];
+};

package/dist/types/hooks/field-mappings/useFieldMappings.d.ts

@@ -0,0 +1,11 @@
+import { FieldMapping, FindFieldMappingsQuery } from '@integration-app/sdk';
+export declare function useFieldMappings(query?: FindFieldMappingsQuery): {
+    items: FieldMapping[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    fieldMappings: FieldMapping[];
+};

package/dist/types/hooks/flows/useFlow.d.ts

@@ -0,0 +1,16 @@
+import { CreateFlowRequest, Flow, FlowAccessor, FlowSelector, UpdateFlowRequest } from '@integration-app/sdk';
+export declare function useFlow(selector: string | FlowSelector | undefined): {
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateFlowRequest) => Promise<Flow | undefined>;
+    patch: (data: Partial<UpdateFlowRequest>) => Promise<void>;
+    put: (data: UpdateFlowRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    flow: Flow | undefined;
+    apply: (integrationKeys: string[]) => Promise<Flow[]>;
+    reset: () => Promise<Flow>;
+    refresh: () => Promise<Flow>;
+    accessor: FlowAccessor | undefined;
+};

package/dist/types/hooks/flows/useFlowInstance.d.ts

@@ -0,0 +1,21 @@
+import { CreateFlowInstanceRequestById, FlowInstance, FlowInstanceAccessor, FlowInstanceSelector, OpenFlowInstanceConfigurationOptions, ResetFlowInstanceOptions, RunFlowOptions, UpdateFlowInstanceRequest } from '@integration-app/sdk';
+export declare function useFlowInstance(selector: string | FlowInstanceSelector | undefined): {
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refreshing: boolean;
+    create: (data: CreateFlowInstanceRequestById) => Promise<FlowInstance | undefined>;
+    patch: (data: Partial<UpdateFlowInstanceRequest>) => Promise<void>;
+    put: (data: UpdateFlowInstanceRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    flowInstance: FlowInstance | undefined;
+    accessor: FlowInstanceAccessor | undefined;
+    refresh: () => Promise<FlowInstance>;
+    enable: () => Promise<void>;
+    disable: () => Promise<void>;
+    reset: (options?: ResetFlowInstanceOptions) => Promise<void>;
+    setup: () => Promise<void>;
+    openConfiguration: (options: OpenFlowInstanceConfigurationOptions) => Promise<void | undefined>;
+    run: (options?: RunFlowOptions) => Promise<import("@integration-app/sdk").FlowRun | undefined>;
+    startRun: (options?: RunFlowOptions) => Promise<import("@integration-app/sdk").FlowRun | undefined>;
+};

package/dist/types/hooks/flows/useFlowInstances.d.ts

@@ -0,0 +1,11 @@
+import { FindFlowInstancesQuery, FlowInstance } from '@integration-app/sdk';
+export declare function useFlowInstances(query?: FindFlowInstancesQuery): {
+    items: FlowInstance[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    flowInstances: FlowInstance[];
+};

package/dist/types/hooks/flows/useFlowRun.d.ts

@@ -0,0 +1,8 @@
+import { FlowRun } from '@integration-app/sdk';
+export declare function useFlowRun(id: string | undefined): {
+    flowRun: FlowRun | undefined;
+    error: any;
+    loading: boolean;
+    refresh: () => Promise<FlowRun>;
+    archive: () => Promise<void>;
+};

package/dist/types/hooks/flows/useFlowRuns.d.ts

@@ -0,0 +1,11 @@
+import { FindFlowRunsQuery, FlowRun } from '@integration-app/sdk';
+export declare function useFlowRuns(query?: FindFlowRunsQuery): {
+    items: FlowRun[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    flowRuns: FlowRun[];
+};

package/dist/types/hooks/flows/useFlows.d.ts

@@ -0,0 +1,11 @@
+import { FindFlowsQuery, Flow } from '@integration-app/sdk';
+export declare function useFlows(query?: FindFlowsQuery): {
+    items: Flow[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+    flows: Flow[];
+};

package/dist/types/hooks/integrations/useConnection.d.ts

@@ -0,0 +1,14 @@
+import { Connection, ConnectionAccessor, CreateConnectionRequest, UpdateConnectionRequest } from '@integration-app/sdk';
+export declare function useConnection(id?: string | undefined): {
+    accessor: ConnectionAccessor | undefined;
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refresh: () => Promise<Connection>;
+    refreshing: boolean;
+    create: (data: CreateConnectionRequest) => Promise<Connection | undefined>;
+    patch: (data: Partial<UpdateConnectionRequest>) => Promise<void>;
+    put: (data: UpdateConnectionRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    connection: Connection | undefined;
+};