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

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;
+};

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

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

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

@@ -0,0 +1,6 @@
+import { ConnectionSpec } from '@integration-app/sdk';
+export declare function useConnectorSpec(integrationIdOrKey: string): {
+    data: ConnectionSpec | undefined;
+    loading: boolean;
+    error: any;
+};

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

@@ -0,0 +1,14 @@
+import { CreateIntegrationRequest, Integration, IntegrationAccessor, UpdateIntegrationRequest } from '@integration-app/sdk';
+export declare function useIntegration(idOrKey: string | undefined): {
+    accessor: IntegrationAccessor | undefined;
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refresh: () => Promise<Integration>;
+    refreshing: boolean;
+    create: (data: CreateIntegrationRequest) => Promise<Integration | undefined>;
+    patch: (data: Partial<UpdateIntegrationRequest>) => Promise<void>;
+    put: (data: UpdateIntegrationRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    integration: Integration | undefined;
+};

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

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

package/dist/types/hooks/keyboard-events.d.ts

@@ -0,0 +1,11 @@
+import { MutableRefObject } from 'react';
+export declare enum EVENT_TYPE {
+    OPTION_DOWN = "option_down",
+    OPTION_UP = "option_up",
+    OPTION_SELECT = "option_select",
+    FORM_SUBMIT = "form_submit"
+}
+type CallbackFunctionType = () => void;
+export declare function useOptionListKeyNavDispatch(ref?: Element | MutableRefObject<any> | null): void;
+export declare function useKeyboardEventSubscribe(event: EVENT_TYPE, callback: CallbackFunctionType): void;
+export {};

package/dist/types/hooks/scenarios/useScenario.d.ts

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

package/dist/types/hooks/scenarios/useScenarios.d.ts

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

package/dist/types/hooks/screens/useScreen.d.ts

@@ -0,0 +1,14 @@
+import { CreateScreenRequest, Screen, ScreenAccessor, ScreenSelector, UpdateScreenRequest } from '@integration-app/sdk';
+export declare function useScreen(selector: ScreenSelector | string): {
+    accessor: ScreenAccessor | undefined;
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refresh: () => Promise<Screen>;
+    refreshing: boolean;
+    create: (data: CreateScreenRequest) => Promise<Screen | undefined>;
+    patch: (data: Partial<UpdateScreenRequest>) => Promise<void>;
+    put: (data: UpdateScreenRequest) => Promise<void>;
+    archive: () => Promise<void>;
+    screen: Screen | undefined;
+};

package/dist/types/hooks/subscriptionStack.d.ts

@@ -0,0 +1,4 @@
+export declare const createSubscriptionStackHook: () => (subscribe: Subscribe, deps: Array<any>) => void;
+type Unsubscribe = () => void;
+type Subscribe = () => Unsubscribe;
+export {};

package/dist/types/hooks/useAutofocus.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export declare function useAutofocus(elementRef: RefObject<HTMLElement>, autoFocus: boolean): void;

package/dist/types/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/hooks/useElement.d.ts

@@ -0,0 +1,22 @@
+import { IntegrationAppClient, WorkspaceElementType } from '@integration-app/sdk';
+export interface BaseElementAccessor<Element, UpdateRequest, CreateRequest> {
+    getUniqueIdentifier?(): string;
+    get(): Promise<Element>;
+    patch?(data: Partial<UpdateRequest>): Promise<Element>;
+    put?(data: UpdateRequest): Promise<Element>;
+    archive?(): Promise<void>;
+    create?(data: CreateRequest): Promise<Element>;
+}
+export declare function useElement<Element, UpdateRequest, CreateRequest, ElementAccessor extends BaseElementAccessor<Element, UpdateRequest, CreateRequest>>(type: WorkspaceElementType, selector: any, accessorGenerator: (integrationAppClient: IntegrationAppClient) => ElementAccessor | undefined): {
+    accessor: ElementAccessor | undefined;
+    item: Element | undefined;
+    loading: boolean;
+    saving: boolean;
+    error: any;
+    refresh: () => Promise<Element>;
+    refreshing: boolean;
+    create: (data: CreateRequest) => Promise<Element | undefined>;
+    patch: (data: Partial<UpdateRequest>) => Promise<void>;
+    put: (data: UpdateRequest) => Promise<void>;
+    archive: () => Promise<void>;
+};

package/dist/types/hooks/useElements.d.ts

@@ -0,0 +1,9 @@
+export declare function useElements<Item>(route: string, query?: any): {
+    items: Item[];
+    refresh: () => Promise<void>;
+    refreshing: boolean;
+    loadMore: () => Promise<void>;
+    loadingMore: boolean;
+    loading: boolean;
+    error: any;
+};

package/dist/types/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/hooks/useForwardedRef.d.ts

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

package/dist/types/hooks/useIntegrationAppSWR.d.ts

@@ -0,0 +1 @@
+export declare function useIntegrationAppSWR(path: string, options?: any): import("swr/_internal").SWRResponse<any, any, any>;

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

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

package/dist/types/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/hooks/useWindowEvent.d.ts

@@ -0,0 +1,4 @@
+import { PopperRefElementType } from '../components/ComboBox/types';
+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/index.d.ts

@@ -0,0 +1,82 @@
+export * from '@integration-app/sdk';
+export * from './contexts/index.js';
+export { useIntegrationAppSWR } from './hooks/useIntegrationAppSWR.js';
+export { useConnection } from './hooks/integrations/useConnection.js';
+export { useConnections } from './hooks/integrations/useConnections.js';
+export { useConnectorSpec } from './hooks/integrations/useConnectorSpec.js';
+export { useIntegration } from './hooks/integrations/useIntegration.js';
+export { useIntegrations } from './hooks/integrations/useIntegrations.js';
+export { useFieldMapping } from './hooks/field-mappings/useFieldMapping.js';
+export { useFieldMappingInstance } from './hooks/field-mappings/useFieldMappingInstance.js';
+export { useFieldMappingInstances } from './hooks/field-mappings/useFieldMappingInstances.js';
+export { useFieldMappings } from './hooks/field-mappings/useFieldMappings.js';
+export { useDataSource } from './hooks/data-sources/useDataSource.js';
+export { useDataSourceInstance } from './hooks/data-sources/useDataSourceInstance.js';
+export { useDataSourceInstanceCollection } from './hooks/data-sources/useDataSourceInstanceCollection.js';
+export { useDataSourceInstances } from './hooks/data-sources/useDataSourceInstances.js';
+export { useDataSources } from './hooks/data-sources/useDataSources.js';
+export { useAppEventSubscription } from './hooks/app-events/useAppEventSubscription.js';
+export { useAppEventSubscriptions } from './hooks/app-events/useAppEventSubscriptions.js';
+export { useAppEventType } from './hooks/app-events/useAppEventType.js';
+export { useAppEventTypes } from './hooks/app-events/useAppEventTypes.js';
+export { useAppEvents } from './hooks/app-events/useAppEvents.js';
+export { useAppDataSchema } from './hooks/app-data-schemas/useAppDataSchema.js';
+export { useAppDataSchemas } from './hooks/app-data-schemas/useAppDataSchemas.js';
+export { useAppDataSchemaInstance } from './hooks/app-data-schemas/useAppDataSchemaInstance.js';
+export { useAppDataSchemaInstances } from './hooks/app-data-schemas/useAppDataSchemaInstances.js';
+export { useFlow } from './hooks/flows/useFlow.js';
+export { useFlows } from './hooks/flows/useFlows.js';
+export { useFlowInstance } from './hooks/flows/useFlowInstance.js';
+export { useFlowInstances } from './hooks/flows/useFlowInstances.js';
+export { useFlowRun } from './hooks/flows/useFlowRun.js';
+export { useFlowRuns } from './hooks/flows/useFlowRuns.js';
+export { useDataLinkTable } from './hooks/data-links/useDataLinkTable.js';
+export { useDataLinkTableInstance } from './hooks/data-links/useDataLinkTableInstance.js';
+export { useDataLinkTableInstances } from './hooks/data-links/useDataLinkTableInstances.js';
+export { useDataLinkTables } from './hooks/data-links/useDataLinkTables.js';
+export { useAction } from './hooks/actions/useAction.js';
+export { useActionInstance } from './hooks/actions/useActionInstance.js';
+export { useActionInstances } from './hooks/actions/useActionInstances.js';
+export { useActions } from './hooks/actions/useActions.js';
+export { useScreen } from './hooks/screens/useScreen.js';
+export { useCustomer } from './hooks/customers/useCustomer.js';
+export { useCustomers } from './hooks/customers/useCustomers.js';
+export { useScenario } from './hooks/scenarios/useScenario.js';
+export { useScenarios } from './hooks/scenarios/useScenarios.js';
+export { useDataCollectionSpec } from './hooks/data-collections/useDataCollectionSpec.js';
+export { useExternalEventSubscriptions } from './hooks/external-events/useExternalEventSubscriptions.js';
+export { useExternalEventSubscription } from './hooks/external-events/useExternalEventSubscription.js';
+export { DataForm } from '@integration-app/sdk';
+export * from './components/Integrations/index';
+export * from './components/DataBuilder/index';
+export * from './components/DataBuilder/Form';
+export * from './components/DataBuilder/FieldDelete';
+export * from './components/DataBuilder/Filter';
+export * from './components/DataBuilder/data-field';
+export * from './components/DataBuilder/FieldList';
+export * from './components/DataBuilderUI';
+export * from './components/DataLinks';
+export * from './components/Button';
+export * from './components/ComboBox';
+export * from './components/ComboBoxElements';
+export * from './components/DropdownUI';
+export * from './components/IntegrationElements';
+export * from './components/SimpleInput';
+export * from './components/Textarea';
+export * from './components/Input';
+export * from './components/Notification';
+export * from './components/Portal';
+export * from './components/Radio';
+export * from './components/SvgIcon';
+export * from './components/Tag';
+export * from './components/Toggle';
+export * from './components/Tooltip';
+export * from './components/AdvancedOptions';
+export * from './components/InlineEditable';
+export * from './components/Popover';
+export * from './components/Truncate';
+export * from './contexts/integration-app-client-context';
+export * from './contexts/integration-app-connection-context';
+export * from './contexts/integration-app-integration-context';
+export * from './components/DataInput';
+export * from './components/SimpleMenu';

package/dist/types/storybook-helpers/withColorPalette.d.ts

@@ -0,0 +1,6 @@
+export declare const withColorPalette: () => {
+    readonly colorPalette: {
+        readonly control: "select";
+        readonly options: readonly ("ruby" | "blue" | "brown" | "crimson" | "cyan" | "gold" | "green" | "indigo" | "lime" | "olive" | "orange" | "pink" | "plum" | "purple" | "red" | "teal" | "tomato" | "violet" | "yellow" | "amber" | "bronze" | "grass" | "iris" | "jade" | "mauve" | "mint" | "sage" | "sand" | "sky" | "slate" | "neutral")[];
+    };
+};

package/dist/types/styled-system/css/css.d.ts

@@ -0,0 +1,22 @@
+/* eslint-disable */
+import type { SystemStyleObject } from '../types/index';
+
+type Styles = SystemStyleObject | undefined | null | false
+
+interface CssRawFunction {
+  (styles: Styles): SystemStyleObject
+  (styles: Styles[]): SystemStyleObject
+  (...styles: Array<Styles | Styles[]>): SystemStyleObject
+  (styles: Styles): SystemStyleObject
+}
+
+interface CssFunction {
+  (styles: Styles): string
+  (styles: Styles[]): string
+  (...styles: Array<Styles | Styles[]>): string
+  (styles: Styles): string
+
+  raw: CssRawFunction
+}
+
+export declare const css: CssFunction;

package/dist/types/styled-system/css/cva.d.ts

@@ -0,0 +1,6 @@
+/* eslint-disable */
+import type { RecipeCreatorFn } from '../types/recipe';
+
+export declare const cva: RecipeCreatorFn
+
+export type { RecipeVariant, RecipeVariantProps } from '../types/recipe';

package/dist/types/styled-system/css/cx.d.ts

@@ -0,0 +1,5 @@
+/* eslint-disable */
+type Argument = string | boolean | null | undefined
+
+/** Conditionally join classNames into a single string */
+export declare function cx(...args: Argument[]): string

package/dist/types/styled-system/css/index.d.ts

@@ -0,0 +1,5 @@
+/* eslint-disable */
+export * from './css';
+export * from './cx';
+export * from './cva';
+export * from './sva';

package/dist/types/styled-system/css/sva.d.ts

@@ -0,0 +1,4 @@
+/* eslint-disable */
+import type { SlotRecipeCreatorFn } from '../types/recipe';
+
+export declare const sva: SlotRecipeCreatorFn

package/dist/types/styled-system/jsx/aspect-ratio.d.ts

@@ -0,0 +1,10 @@
+/* eslint-disable */
+import type { FunctionComponent } from 'react'
+import type { AspectRatioProperties } from '../patterns/aspect-ratio';
+import type { HTMLStyledProps } from '../types/jsx';
+import type { DistributiveOmit } from '../types/system-types';
+
+export interface AspectRatioProps extends AspectRatioProperties, DistributiveOmit<HTMLStyledProps<'div'>, keyof AspectRatioProperties | 'aspectRatio'> {}
+
+
+export declare const AspectRatio: FunctionComponent<AspectRatioProps>