@membranehq/react 0.1.0

package/dist/types/helpers/hooks/useDeepEffect.d.ts

@@ -0,0 +1,3 @@
+import { EffectCallback } from 'react';
+export declare const useDeepEffect: (fn: EffectCallback, dependencies?: any[], comparisonFn?: (a: any, b: any) => boolean) => void;
+export declare const useDeepMemo: <TKey, TValue>(memoFn: () => TValue, key: TKey) => TValue;

package/dist/types/helpers/hooks/useEventStopPropagation.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+type EventType = React.MouseEvent<any, any> | React.ChangeEvent<any> | React.KeyboardEvent<any> | React.SyntheticEvent<any> | TouchEvent | MouseEvent | KeyboardEvent;
+export type EventHandlerFunctionType = (event?: EventType) => any;
+export default function useEventStopPropagation(fn: EventHandlerFunctionType | true): ((event: EventType) => void) | undefined;
+export {};

package/dist/types/helpers/hooks/useForwardedRef.d.ts

@@ -0,0 +1 @@
+export declare function useForwardedRef<T>(ref: any): import("react").RefObject<T>;

package/dist/types/helpers/hooks/useIsTextTruncated.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export declare const useIsTextTruncated: (ref: RefObject<HTMLElement>) => boolean;

package/dist/types/helpers/hooks/useResizeObserver.d.ts

@@ -0,0 +1,13 @@
+import { RefObject } from 'react';
+declare function useResizeObserver<T extends HTMLElement>(ref: RefObject<T> | T | null | undefined, callback: UseResizeObserverCallback): void;
+export type UseResizeObserverCallback = (entry: {
+    resized: {
+        width?: boolean;
+        height?: boolean;
+    };
+    size: {
+        width?: number;
+        height?: number;
+    };
+}) => any;
+export default useResizeObserver;

package/dist/types/helpers/hooks/useThrottle.d.ts

@@ -0,0 +1 @@
+export declare function useThrottle<T>(value: T, interval?: number): T;

package/dist/types/helpers/hooks/useWindowEvent.d.ts

@@ -0,0 +1,4 @@
+import { PopperRefElementType } from 'components/ComboBox/shared.js';
+export declare function useWindowEvent<TType extends keyof WindowEventMap>(type: TType, listener: (this: Window, ev: WindowEventMap[TType]) => any): void;
+export declare function useClickOutsideElements(refs: Array<PopperRefElementType | null | undefined>, onClickOutside: ((event: MouseEvent | TouchEvent) => void) | undefined): void;
+export declare function useWindowResize(listener: (...props: any[]) => any, ms?: number): void;

package/dist/types/helpers/intersperse.d.ts

@@ -0,0 +1 @@
+export declare function intersperse<T>(arr: T[], separator: T): T[];

package/dist/types/helpers/simple-unique-id.d.ts

@@ -0,0 +1 @@
+export declare const simpleUniqueId: (length?: number) => string;

package/dist/types/helpers/types.d.ts

@@ -0,0 +1,8 @@
+import { DOMAttributes } from 'react';
+export type StrictAsChild<T extends HTMLElement> = {
+    asChild: true;
+    children: NonNullable<DOMAttributes<T>['children']>;
+} | {
+    asChild?: false;
+    children?: never;
+};

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

@@ -0,0 +1,16 @@
+import { CreateActionRequest, Action, ActionAccessor, ActionSelector, UpdateActionRequest } from '@membranehq/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 '@membranehq/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("@membranehq/sdk").ActionRunResponse | undefined>;
+};

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

@@ -0,0 +1,11 @@
+import { FindActionInstancesQuery, ActionInstance } from '@membranehq/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 '@membranehq/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 '@membranehq/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 '@membranehq/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 '@membranehq/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 '@membranehq/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 '@membranehq/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 '@membranehq/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,14 @@
+import { AppEventType, CreateAppEventTypeRequest, UpdateAppEventTypeRequest, AppEventTypeAccessor } from '@membranehq/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 '@membranehq/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 '@membranehq/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 '@membranehq/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 '@membranehq/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,11 @@
+import { DataCollectionSpec } from '@membranehq/sdk';
+export declare function useDataCollectionSpec({ path, key, integrationId, }: {
+    path?: string | undefined;
+    key?: string | undefined;
+    integrationId: string;
+}): {
+    dataCollectionSpec: DataCollectionSpec | undefined;
+    loading: boolean;
+    error: unknown;
+    refreshing: boolean;
+};

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

@@ -0,0 +1,14 @@
+import { CreateDataLinkTableRequest, DataLinkTable, DataLinkTableAccessor } from '@membranehq/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 '@membranehq/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("@membranehq/sdk").FindDataLinksInTableQuery) => Promise<import("@membranehq/sdk").FindDataLinksResponse>) | undefined;
+    createLink: ((data: import("@membranehq/sdk").CreateDataLinkRequest) => Promise<void>) | undefined;
+    deleteLink: ((data: import("@membranehq/sdk").DeleteDataLinkRequest) => Promise<void>) | undefined;
+};

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

@@ -0,0 +1,11 @@
+import { FindDataLinkTableInstancesQuery, DataLinkTableInstance } from '@membranehq/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 '@membranehq/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,17 @@
+import { CreateDataSourceRequest, DataSource, DataSourceAccessor, DataSourceSelector, UpdateDataSourceRequest } from '@membranehq/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>;
+    setup: () => Promise<void>;
+    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 '@membranehq/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("@membranehq/sdk").DataCollectionListResponse | undefined>;
+    findRecords: (request?: DataCollectionFindRequest) => Promise<import("@membranehq/sdk").DataCollectionFindResponse | undefined>;
+    findRecordById: (id: string) => Promise<import("@membranehq/sdk").DataCollectionFindByIdResponse | undefined>;
+    createRecord: (request?: DataCollectionCreateRequest) => Promise<import("@membranehq/sdk").DataCollectionCreateResponse | undefined>;
+    updateRecord: (request?: DataCollectionUpdateRequest) => Promise<import("@membranehq/sdk").DataCollectionUpdateResponse | undefined>;
+    deleteRecord: (id?: string) => Promise<import("@membranehq/sdk").DataCollectionDeleteResponse | undefined>;
+    unifiedFieldsToNative: (unifiedFields: any) => Promise<any>;
+    getCollection: () => Promise<import("@membranehq/sdk").DataCollectionSpec | undefined>;
+};

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

@@ -0,0 +1,7 @@
+import { DataCollectionSpec, DataSourceInstance } from '@membranehq/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 '@membranehq/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 '@membranehq/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 '@membranehq/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 '@membranehq/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,17 @@
+import { CreateFieldMappingRequest, FieldMapping, FieldMappingAccessor, FieldMappingSelector, UpdateFieldMappingRequest } from '@membranehq/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>;
+    setup: () => 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 '@membranehq/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 '@membranehq/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 '@membranehq/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 '@membranehq/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;
+};