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

package/dist/types/components/SvgIcon/BasicEntities.d.ts

@@ -0,0 +1,35 @@
+export declare function SvgIconUnifiedInterfaces({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconUnifiedInterface({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconIntegration({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconFieldMappings({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare const SvgIconFieldMapping: typeof SvgIconFieldMappings;
+export declare function SvgIconFlows({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare const SvgIconFlow: typeof SvgIconFlows;
+export declare function SvgIconDataSources({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconObjectLinks({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconObjectLink({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconDataSchema({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconDataSchemas({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconAppEventSubscriptions({ ...props }: {
+    [x: string]: any;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,121 @@
+import { SVGProps } from 'react';
+export declare enum SvgIconType {
+    ActionBarDuplicate = "ActionBarDuplicate",
+    ActionBarProperties = "ActionBarProperties",
+    Add = "Add",
+    AddCircle = "AddCircle",
+    AlertCircle = "AlertCircle",
+    AlertOctagon = "AlertOctagon",
+    AlertTriangle = "AlertTriangle",
+    AlignLeft = "AlignLeft",
+    AppIcon = "AppIcon",
+    DefaultWorkspaceIcon = "DefaultWorkspaceIcon",
+    Archive = "Archive",
+    Array = "Array",
+    ArrowRight = "ArrowRight",
+    Back = "Back",
+    Braces = "Braces",
+    BreadcrumbStep = "BreadcrumbStep",
+    Cancel = "Cancel",
+    Check = "Check",
+    Checks = "Checks",
+    ChevronDown = "ChevronDown",
+    ChevronLeft = "ChevronLeft",
+    ChevronRight = "ChevronRight",
+    ChevronUp = "ChevronUp",
+    Close = "Close",
+    Copy = "Copy",
+    Code = "Code",
+    Delete = "Delete",
+    Disconnect = "Disconnect",
+    DotsVertical = "DotsVertical",
+    Download = "Download",
+    Drag = "Drag",
+    Edit = "Edit",
+    EditorVisual = "EditorVisual",
+    Eye = "Eye",
+    EyeOff = "EyeOff",
+    ExternalLink = "ExternalLink",
+    Folder = "Folder",
+    Function = "Function",
+    InfoCircle = "InfoCircle",
+    Impersonation = "Impersonation",
+    HamburgerMenu = "HamburgerMenu",
+    Link = "Link",
+    Loader = "Loader",
+    Lookup = "Lookup",
+    ObjectLevel = "ObjectLevel",
+    PlayerPlay = "PlayerPlay",
+    PlayerPlayFilled = "PlayerPlayFilled",
+    PlayerStopFilled = "PlayerStopFilled",
+    QuestionMark = "QuestionMark",
+    Refresh = "Refresh",
+    Reset = "Reset",
+    SchemaType_array = "SchemaTypeArray",
+    SchemaType_boolean = "SchemaTypeBoolean",
+    SchemaType_connection = "SchemaTypeConnection",
+    SchemaType_number = "SchemaTypeNumber",
+    SchemaType_integer = "SchemaTypeInteger",
+    SchemaType_object = "SchemaTypeObject",
+    SchemaType_request = "SchemaTypeRequest",
+    SchemaType_string = "SchemaTypeString",
+    Search = "Search",
+    Settings = "Settings",
+    SyncLeft = "SyncLeft",
+    SyncRight = "SyncRight",
+    SyncTwoWays = "SyncTwoWays",
+    TestRunningLoader = "TestRunningLoader",
+    ThreeDots = "ThreeDots",
+    ValueMapping = "ValueMapping",
+    Variable = "Variable",
+    Unlink = "Unlink",
+    WindowMinimize = "WindowMinimize",
+    WindowMaximize = "WindowMaximize",
+    Writing = "Writing",
+    ActionEntity = "Action",
+    ActionsEntity = "Actions",
+    TemplatesEntity = "Templates",
+    TemplateEntity = "Template",
+    IntegrationsEntity = "Integrations",
+    IntegrationEntity = "Integration",
+    ApisEntity = "Apis",
+    ApiEntity = "Api",
+    FieldMappingsEntity = "FieldMappings",
+    FieldMappingEntity = "FieldMapping",
+    FlowsEntity = "Flows",
+    FlowEntity = "Flow",
+    DataSourcesEntity = "DataSources",
+    DataSourceEntity = "DataSource",
+    ObjectLinksEntity = "ObjectLinks",
+    ObjectLinkEntity = "ObjectLink",
+    UsersEntity = "UsersEntity",
+    UserEntity = "UserEntity",
+    DataSchemasEntity = "DataSchemas",
+    DataSchemaEntity = "DataSchema",
+    DataLinkEntity = "DataLink",
+    AppEventSubscriptionsEntity = "AppEventSubscriptions",
+    AppEventSubscriptionEntity = "AppEventSubscription",
+    CustomFieldsEntity = "CustomFields",
+    MonitoringEntity = "Monitoring",
+    LogEntity = "LogEntity",
+    UDMEntity = "UDMEntity",
+    UdmActivities = "UdmActivities",
+    UdmCampains = "UdmCampains",
+    UdmCompanies = "UdmCompanies",
+    UdmContacts = "UdmContacts",
+    UdmDeals = "UdmDeals",
+    UdmDealProducts = "UdmDealProducts",
+    UdmProducts = "UdmProducts",
+    UdmUsers = "UdmUsers",
+    UdmMeetings = "UdmMeetings",
+    UdmTasks = "UdmTasks",
+    UdmNotes = "UdmNotes",
+    UdmEmails = "UdmEmails"
+}
+type CustomSvgIconProps = SVGProps<SVGSVGElement>;
+type SvgIconProps = Omit<CustomSvgIconProps, 'type'> & {
+    type: SvgIconType;
+};
+export declare function SvgIcon({ type, ...props }: SvgIconProps): import("react/jsx-runtime").JSX.Element;
+export declare function SvgIconLevel(props: CustomSvgIconProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/Tag/Components.d.ts

@@ -0,0 +1,12 @@
+import { ImgHTMLAttributes } from 'react';
+import { SvgIconType } from '../SvgIcon';
+export declare function TagSvgIcon({ type, className, ...props }: {
+    type: SvgIconType;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function TagImage({ className, alt, ...props }: ImgHTMLAttributes<HTMLImageElement>): import("react/jsx-runtime").JSX.Element;
+export declare function TagConfigButton({ error, icon, onClick, }: {
+    error?: boolean | undefined;
+    icon?: SvgIconType | undefined;
+    onClick: any;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Tag/SegmentSeparator.d.ts

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

package/dist/types/components/Tag/TagPlaceholder.d.ts

@@ -0,0 +1,5 @@
+import { HTMLAttributes } from 'react';
+interface ITagPlaceholderProps extends HTMLAttributes<HTMLSpanElement> {
+}
+export declare const TagPlaceholder: import("react").ForwardRefExoticComponent<ITagPlaceholderProps & import("react").RefAttributes<HTMLSpanElement>>;
+export {};

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

@@ -0,0 +1,24 @@
+import { ComponentProps, PropsWithChildren } from 'react';
+import { TagConfigButton, TagImage, TagSvgIcon } from './Components';
+export * from './TagPlaceholder';
+export interface ITagProps extends ComponentProps<any> {
+    truncate?: boolean;
+    inactive?: boolean;
+    disabled?: boolean;
+}
+export interface IBasicTagProps extends ITagProps {
+    tooltip?: string;
+}
+export declare const GenericTag: import("react").ForwardRefExoticComponent<Omit<ITagProps, "ref"> & import("react").RefAttributes<HTMLSpanElement>>;
+export declare const Tag: import("react").ForwardRefExoticComponent<Omit<IBasicTagProps, "ref"> & import("react").RefAttributes<HTMLSpanElement>> & {
+    SvgIcon: typeof TagSvgIcon;
+    Image: typeof TagImage;
+    ConfigButton: typeof TagConfigButton;
+    Lookup: typeof TagLookup;
+};
+export default Tag;
+interface ILookupTagProps extends ITagProps {
+    onConfigClick: () => void;
+    configError?: boolean;
+}
+declare function TagLookup({ children, disabled, onConfigClick, configError, }: PropsWithChildren<ILookupTagProps>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,20 @@
+import { TextareaHTMLAttributes } from 'react';
+interface TextareaGenericProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    className?: string;
+    variant?: 'border' | 'background' | 'transparent';
+}
+export interface TextareaWithUndefinedAutoHeightProps extends TextareaGenericProps {
+    autoHeight?: never;
+    maxHeight?: never;
+}
+export interface TextareaWithAutoHeightProps extends TextareaGenericProps {
+    autoHeight: true;
+    maxHeight?: string | number;
+}
+export interface TextareaWithoutAutoHeightProps extends TextareaGenericProps {
+    autoHeight: false;
+    maxHeight?: never;
+}
+export type TextareaProps = TextareaWithAutoHeightProps | TextareaWithoutAutoHeightProps | TextareaWithUndefinedAutoHeightProps;
+export declare const Textarea: import("react").ForwardRefExoticComponent<TextareaProps & import("react").RefAttributes<HTMLTextAreaElement>>;
+export {};

package/dist/types/components/Toggle/Toggle.d.ts

@@ -0,0 +1,2 @@
+import { ToggleProps } from './types';
+export declare function Toggle({ children, ...props }: ToggleProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Toggle/ToggleOnOff.d.ts

@@ -0,0 +1,2 @@
+import { ToggleProps } from './types';
+export declare function ToggleOnOff({ checked, disabled, loading, onChange, className, ...props }: ToggleProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,4 @@
+import { Toggle } from './Toggle';
+import { ToggleOnOff } from './ToggleOnOff';
+import type { ToggleProps } from './types';
+export { Toggle, ToggleOnOff, ToggleProps };

package/dist/types/components/Toggle/types.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+import { SwitchProps } from '@headlessui/react';
+type GenericToggleProps = SwitchProps<'button'> & {
+    checked: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    onChange?: (checked: boolean) => void;
+    className?: string;
+};
+type TogglePropsWithChildren = GenericToggleProps & {
+    children?: React.ReactNode;
+};
+type TogglePropsWithoutChildren = GenericToggleProps & {
+    children?: never;
+};
+export type ToggleProps = TogglePropsWithChildren | TogglePropsWithoutChildren;
+export {};

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

@@ -0,0 +1,15 @@
+import React, { ReactElement } from 'react';
+import { Tooltip as PTooltip } from '../../ui-kit/tooltip';
+type RootProps = React.ComponentProps<typeof PTooltip.Root>;
+export type GenericTooltipProps = {
+    tooltip: string | ReactElement;
+    placement?: NonNullable<RootProps['positioning']>['placement'];
+    delayToShow?: number;
+    delayToHide?: number;
+    offset?: [number, number];
+    className?: string;
+    disabled?: boolean;
+    children: ReactElement;
+};
+export declare const Tooltip: React.ForwardRefExoticComponent<GenericTooltipProps & React.RefAttributes<HTMLDivElement>>;
+export {};

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

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+export declare function Truncate({ mode, children, endLetters, className, }: {
+    mode?: 'end' | 'middle';
+    children: string | ReactNode;
+    endLetters?: number;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

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-client-context.d.ts

@@ -0,0 +1,10 @@
+import { IntegrationAppClient } from '@integration-app/sdk';
+interface IIntegrationAppClientContext {
+    client: IntegrationAppClient;
+}
+export declare const IntegrationAppClientProvider: ({ client, children }: {
+    client: any;
+    children: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function useIntegrationAppClient(): IIntegrationAppClientContext;
+export {};

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

@@ -0,0 +1,9 @@
+interface IIntegrationAppConnectionContext {
+    connectionId: string;
+}
+export declare const IntegrationAppConnectionProvider: ({ connectionId, children, }: {
+    connectionId: any;
+    children: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function useIntegrationAppConnection(): IIntegrationAppConnectionContext;
+export {};

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/contexts/integration-app-integration-context.d.ts

@@ -0,0 +1,9 @@
+interface IIntegrationAppIntegrationContext {
+    integrationId: string;
+}
+export declare const IntegrationAppIntegrationProvider: ({ integrationId, children, }: {
+    integrationId: any;
+    children: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function useIntegrationAppIntegration(): IIntegrationAppIntegrationContext;
+export {};

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

@@ -0,0 +1 @@
+export default function debounce<A = unknown, R = void>(fn: (args?: A) => R, ms: number): [(args?: A) => Promise<R>, () => void];

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

@@ -0,0 +1,3 @@
+import { ForwardedRef, MutableRefObject } from 'react';
+export type RefOrElementType<T = HTMLElement> = ForwardedRef<T | null> | MutableRefObject<T | null> | T | null;
+export declare function getRefElement<T>(ref?: RefOrElementType<T>): T | null;

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