@membranehq/sdk 0.1.0

package/dist/dts/connectors/data-locations/collections/events/methods.d.ts

@@ -0,0 +1,15 @@
+import { ConnectorDataCollection } from '..';
+import { DataSchema } from '../../../../data-schema';
+import { ConnectorMethodImplementationType } from '../../../methods';
+import { ConnectorDataCollectionEvent } from '.';
+interface ConnectorDataCollectionEventMethodTypeArgs<ImplementationFields = unknown> {
+    event: ConnectorDataCollectionEvent<ImplementationFields>;
+    collection: ConnectorDataCollection;
+}
+export interface ConnectorDataCollectionEventMethodType<ImplementationFields = unknown> {
+    fileKey?: string;
+    getInputSchema?: (args: ConnectorDataCollectionEventMethodTypeArgs<ImplementationFields>) => DataSchema;
+    getOutputSchema?: (args: ConnectorDataCollectionEventMethodTypeArgs<ImplementationFields>) => DataSchema;
+    supportedImplementationTypes: ConnectorMethodImplementationType[];
+}
+export {};

package/dist/dts/connectors/data-locations/collections/index.d.ts

@@ -0,0 +1,70 @@
+import { DataSchema } from '../../../data-schema';
+import { ConnectorDataLocationBase } from '../base';
+import { ConnectorDataLocationMethod } from '../methods';
+import { ConnectorDataCollectionEvent } from './events';
+import { ConnectorDataCollectionMethodType } from './methods/base';
+import { DataCollectionCreateConfigType } from './methods/create';
+import { DataCollectionListConfigType } from './methods/list';
+import { DataCollectionMatchConfigType } from './methods/match';
+import { DataCollectionUpdateConfigType } from './methods/update';
+export * from './events';
+export declare const DataLocationTypeCollection: {
+    spec: ConnectorDataCollectionMethodType<unknown>;
+    recordFromFields: ConnectorDataCollectionMethodType<unknown>;
+    customFieldsSchema: ConnectorDataCollectionMethodType<unknown>;
+    fieldsFromApi: ConnectorDataCollectionMethodType<unknown>;
+    fieldsToApi: ConnectorDataCollectionMethodType<unknown>;
+    methods: {
+        list: ConnectorDataCollectionMethodType<DataCollectionListConfigType>;
+        findById: ConnectorDataCollectionMethodType<unknown>;
+        match: ConnectorDataCollectionMethodType<DataCollectionMatchConfigType>;
+        search: ConnectorDataCollectionMethodType<unknown>;
+        create: ConnectorDataCollectionMethodType<DataCollectionCreateConfigType>;
+        update: ConnectorDataCollectionMethodType<DataCollectionUpdateConfigType>;
+        delete: ConnectorDataCollectionMethodType<unknown>;
+        find: ConnectorDataCollectionMethodType<{
+            queryFields: string[];
+        }>;
+    };
+    recordToApi: ConnectorDataCollectionMethodType<unknown>;
+    recordFromApi: ConnectorDataCollectionMethodType<unknown>;
+    recordFromApiMapping: ConnectorDataCollectionMethodType<unknown>;
+    recordFromApiCode: ConnectorDataCollectionMethodType<unknown>;
+    fieldsToApiMapping: ConnectorDataCollectionMethodType<unknown>;
+    fieldsToApiCode: ConnectorDataCollectionMethodType<unknown>;
+};
+export interface ConnectorDataCollection extends ConnectorDataLocationBase {
+    type: 'collection';
+    fieldsSchema?: DataSchema;
+    isHidden?: boolean;
+    customFields?: boolean;
+    customFieldsSchema?: ConnectorDataLocationMethod;
+    spec?: ConnectorDataLocationMethod;
+    recordFromFields?: ConnectorDataLocationMethod;
+    fieldsFromApi?: ConnectorDataLocationMethod;
+    recordFromApi?: ConnectorDataLocationMethod;
+    recordFromApiCode?: ConnectorDataLocationMethod;
+    recordFromApiMapping?: ConnectorDataLocationMethod;
+    recordToApi?: ConnectorDataLocationMethod;
+    fieldsToApi?: ConnectorDataLocationMethod;
+    fieldsToApiCode?: ConnectorDataLocationMethod;
+    fieldsToApiMapping?: ConnectorDataLocationMethod;
+    methods?: {
+        list?: ConnectorDataLocationMethod<DataCollectionListConfigType>;
+        findById?: ConnectorDataLocationMethod;
+        match?: ConnectorDataLocationMethod<DataCollectionMatchConfigType>;
+        search?: ConnectorDataLocationMethod;
+        create?: ConnectorDataLocationMethod<DataCollectionCreateConfigType>;
+        update?: ConnectorDataLocationMethod<DataCollectionUpdateConfigType>;
+        delete?: ConnectorDataLocationMethod;
+        find?: ConnectorDataLocationMethod<{
+            queryFields?: string[];
+        }>;
+    };
+    events?: Partial<Record<'created' | 'updated' | 'deleted', ConnectorDataCollectionEvent>>;
+    udm?: Partial<Record<string, {
+        extract?: ConnectorDataLocationMethod;
+        parse?: ConnectorDataLocationMethod;
+    }>>;
+}
+export declare const ConnectorDataCollectionMethodKeys: Array<keyof typeof DataLocationTypeCollection.methods>;

package/dist/dts/connectors/data-locations/collections/methods/base.d.ts

@@ -0,0 +1,24 @@
+import { ConnectorDataCollection } from '..';
+import { DataSchema } from '../../../../data-schema';
+import { ConnectorMethodImplementationType } from '../../../methods';
+import { ConnectorSpec } from '../../../types';
+import { ConnectorDataLocationMethod } from '../../methods';
+import { DataCollectionSpec } from '../../types';
+export interface ConnectorDataCollectionMethodType<ConfigFields = unknown> {
+    name?: string;
+    description?: string;
+    fileKey?: string;
+    getConfigSchema?: (args: ConnectorDataCollectionMethodTypeArgs<ConfigFields>) => DataSchema;
+    getInputSchema?: (args: ConnectorDataCollectionMethodTypeArgs<ConfigFields>) => DataSchema;
+    getOutputSchema?: (args: ConnectorDataCollectionMethodTypeArgs<ConfigFields>) => DataSchema;
+    supportedImplementationTypes: ConnectorMethodImplementationType[];
+    isDeprecated?: boolean;
+}
+interface ConnectorDataCollectionMethodTypeArgs<ConfigFields = unknown> {
+    method?: ConnectorDataLocationMethod<ConfigFields>;
+    collectionHandler?: ConnectorDataCollection;
+    collectionSpec?: DataCollectionSpec;
+    connectorSpec?: ConnectorSpec;
+    parameters?: any;
+}
+export {};

package/dist/dts/connectors/data-locations/collections/methods/create.d.ts

@@ -0,0 +1,7 @@
+import { ConnectorDataCollectionMethodType } from './base';
+export interface DataCollectionCreateConfigType {
+    fields?: string[];
+    requiredFields?: string[];
+    excludedFields?: string[];
+}
+export declare const DataCollectionMethodCreate: ConnectorDataCollectionMethodType<DataCollectionCreateConfigType>;

package/dist/dts/connectors/data-locations/collections/methods/delete.d.ts

@@ -0,0 +1,2 @@
+import { ConnectorDataCollectionMethodType } from './base';
+export declare const DataCollectionMethodDelete: ConnectorDataCollectionMethodType;

package/dist/dts/connectors/data-locations/collections/methods/find-by-id.d.ts

@@ -0,0 +1,2 @@
+import { ConnectorDataCollectionMethodType } from './base';
+export declare const DataCollectionMethodFindById: ConnectorDataCollectionMethodType;

package/dist/dts/connectors/data-locations/collections/methods/find.d.ts

@@ -0,0 +1,6 @@
+import { ConnectorDataCollectionMethodType } from './base';
+type DataCollectionFindConfigType = {
+    queryFields: string[];
+};
+export declare const DataCollectionMethodFind: ConnectorDataCollectionMethodType<DataCollectionFindConfigType>;
+export {};

package/dist/dts/connectors/data-locations/collections/methods/list.d.ts

@@ -0,0 +1,5 @@
+import { ConnectorDataCollectionMethodType } from './base';
+export interface DataCollectionListConfigType {
+    filterFields?: string[];
+}
+export declare const DataCollectionMethodList: ConnectorDataCollectionMethodType<DataCollectionListConfigType>;

package/dist/dts/connectors/data-locations/collections/methods/match.d.ts

@@ -0,0 +1,5 @@
+import { ConnectorDataCollectionMethodType } from './base';
+export interface DataCollectionMatchConfigType {
+    fields?: string[];
+}
+export declare const DataCollectionMethodMatch: ConnectorDataCollectionMethodType<DataCollectionMatchConfigType>;

package/dist/dts/connectors/data-locations/collections/methods/search.d.ts

@@ -0,0 +1,2 @@
+import { ConnectorDataCollectionMethodType } from './base';
+export declare const DataCollectionMethodSearch: ConnectorDataCollectionMethodType;

package/dist/dts/connectors/data-locations/collections/methods/update.d.ts

@@ -0,0 +1,6 @@
+import { ConnectorDataCollectionMethodType } from './base';
+export interface DataCollectionUpdateConfigType {
+    fields?: string[];
+    excludedFields?: string[];
+}
+export declare const DataCollectionMethodUpdate: ConnectorDataCollectionMethodType<DataCollectionUpdateConfigType>;

package/dist/dts/connectors/data-locations/directories/index.d.ts

@@ -0,0 +1,17 @@
+import { ConnectorDataLocationBase } from '../base';
+import { ConnectorDataLocationMethod } from '../methods';
+import { ConnectorDataDirectoryMethodType } from './methods/base';
+export declare const DataLocationTypeDirectory: {
+    spec: ConnectorDataDirectoryMethodType<unknown>;
+    methods: {
+        list: ConnectorDataDirectoryMethodType<unknown>;
+    };
+};
+export interface ConnectorDataDirectory extends ConnectorDataLocationBase {
+    type: 'directory';
+    spec?: ConnectorDataLocationMethod;
+    methods: {
+        list: ConnectorDataLocationMethod<any>;
+    };
+}
+export declare const ConnectorDataDirectoryMethodKeys: Array<keyof typeof DataLocationTypeDirectory.methods>;

package/dist/dts/connectors/data-locations/directories/methods/base.d.ts

@@ -0,0 +1,18 @@
+import { ConnectorDataDirectory } from '..';
+import { DataSchema } from '../../../../data-schema';
+import { ConnectorMethodImplementationType } from '../../../methods';
+import { ConnectorDataLocationMethod } from '../../methods';
+export interface ConnectorDataDirectoryMethodType<ConfigType = unknown> {
+    name?: string;
+    description?: string;
+    fileKey?: string;
+    getConfigSchema?: (args: ConnectorDataDirectoryMethodTypeArgs<ConfigType>) => DataSchema;
+    getInputSchema?: (args: ConnectorDataDirectoryMethodTypeArgs<ConfigType>) => DataSchema;
+    getOutputSchema?: (args: ConnectorDataDirectoryMethodTypeArgs<ConfigType>) => DataSchema;
+    supportedImplementationTypes: ConnectorMethodImplementationType[];
+}
+interface ConnectorDataDirectoryMethodTypeArgs<ConfigType = unknown> {
+    method: ConnectorDataLocationMethod<ConfigType>;
+    directory: ConnectorDataDirectory;
+}
+export {};

package/dist/dts/connectors/data-locations/directories/methods/list.d.ts

@@ -0,0 +1,2 @@
+import { ConnectorDataDirectoryMethodType } from './base';
+export declare const DataDirectoryMethodList: ConnectorDataDirectoryMethodType;

package/dist/dts/connectors/data-locations/index.d.ts

@@ -0,0 +1,6 @@
+export * from './base';
+export * from './collections';
+export * from './directories';
+export * from './methods';
+export * from './types';
+export * from './utils';

package/dist/dts/connectors/data-locations/methods.d.ts

@@ -0,0 +1,6 @@
+import { ConnectorMethodImplementation, ConnectorMethodImplementationBase, ConnectorMethodImplementationType } from '../methods';
+import { ApiRequestSpec } from './types';
+export type ConnectorDataLocationMethod<ConfigFields = unknown, ImplementationFields extends ConnectorMethodImplementation | ConnectorMethodImplementationBase = ConnectorMethodImplementationBase> = {
+    apiRequests?: ApiRequestSpec[];
+} & ImplementationFields & ConfigFields;
+export declare const DataLocationMethodImplementationTypes: ConnectorMethodImplementationType[];

package/dist/dts/connectors/data-locations/types.d.ts

@@ -0,0 +1,258 @@
+import { ConnectorDataCollection } from './collections';
+import { ConnectorDataDirectory } from './directories';
+import { DataCollectionEvent, DataCollectionEventType, DataRecord } from '../../data-collections';
+import { DataSchema } from '../../data-schema';
+export type DataLocationSpec = DataCollectionSpec | DataDirectorySpec;
+export declare enum DataLocationType {
+    directory = "directory",
+    collection = "collection"
+}
+export interface DataLocationListItem {
+    key: string;
+    name: string;
+    type: DataLocationType;
+    isHidden?: boolean;
+}
+export interface DataLocationPointer {
+    key: string;
+    parameters?: Record<string, any>;
+    type?: DataLocationType;
+}
+export interface DataLocation {
+    key?: string;
+    parameters?: any;
+    path?: string;
+    name?: string;
+    type?: DataLocationType;
+    isDefault?: boolean;
+    read?: boolean;
+    write?: boolean;
+}
+export interface DataLocationMixin {
+    key: string;
+    parameters?: any;
+}
+interface DataLocationSpecBase {
+    type: DataLocationType;
+    key?: string;
+    name: string;
+    parametersSchema?: DataSchema;
+}
+export interface DataCollectionSpec extends DataLocationSpecBase {
+    fieldsSchema?: DataSchema;
+    list?: DataCollectionListSpec;
+    search?: DataCollectionSearchSpec;
+    match?: DataCollectionMatchSpec;
+    findById?: DataCollectionFindByIdSpec;
+    create?: DataCollectionCreateSpec;
+    update?: DataCollectionUpdateSpec;
+    delete?: DataCollectionDeleteSpec;
+    events?: DataCollectionEventsSpec;
+    customFields?: boolean;
+    udm?: DataCollectionUdmsSpec;
+    find?: DataCollectionFindSpec;
+}
+export interface ApiRequestSpec {
+    path: any;
+    method: any;
+}
+export declare enum DataDirectoryOperation {
+    list = "list"
+}
+export interface DataDirectorySpec extends DataLocationSpecBase {
+    locations?: DataLocation[];
+}
+export interface DataCollectionMethodSpec {
+    apiRequests?: ApiRequestSpec[];
+}
+export interface DataCollectionFindSpec extends DataCollectionMethodSpec {
+    queryFields?: string[];
+}
+export interface DataCollectionMatchSpec extends DataCollectionMethodSpec {
+    fields?: string[];
+}
+export interface DataCollectionListSpec extends DataCollectionMethodSpec {
+    filterFields?: string[];
+}
+export interface DataCollectionSearchSpec extends DataCollectionMethodSpec {
+}
+export interface DataCollectionFindByIdSpec extends DataCollectionMethodSpec {
+}
+export interface DataCollectionCreateSpec extends DataCollectionMethodSpec {
+    fields?: string[];
+    requiredFields?: string[];
+    excludedFields?: string[];
+}
+export interface DataCollectionUpdateSpec extends DataCollectionMethodSpec {
+    fields?: string[];
+    excludedFields?: string[];
+}
+export interface DataCollectionDeleteSpec extends DataCollectionMethodSpec {
+}
+export type DataCollectionUdmSpec = {
+    fields?: string[];
+    extract?: Record<string, any>;
+    parse?: Record<string, any>;
+};
+export type DataCollectionUdmsSpec = Record<string, DataCollectionUdmSpec>;
+export type DataCollectionEventTypeSpec = {
+    type: 'push' | 'pull';
+    isFullScan?: boolean;
+    isIdOnly?: boolean;
+};
+export type DataCollectionEventsSpec = {
+    [value in DataCollectionEventType]: DataCollectionEventTypeSpec;
+} & {
+    all?: DataCollectionEventTypeSpec;
+};
+export interface DataCollectionMethodRequest {
+    parameters?: Record<string, any>;
+}
+export interface DataCollectionFindRequest {
+    query?: any;
+    cursor?: string;
+}
+export interface DataCollectionFindResponse {
+    records: DataRecord[];
+    cursor?: string;
+}
+export interface DataCollectionListRequest extends DataCollectionMethodRequest {
+    filter?: any;
+    unifiedFilter?: any;
+    cursor?: string;
+}
+export interface DataCollectionListResponseDrilldown {
+    parameters?: Record<string, any>;
+    filter?: Record<string, any>;
+}
+export interface DataCollectionListResponse {
+    records: DataRecord[];
+    drilldowns?: Array<DataCollectionListResponseDrilldown>;
+    cursor?: string;
+}
+export interface DataCollectionSearchRequest extends DataCollectionMethodRequest {
+    query: string;
+    cursor?: string;
+}
+export interface DataCollectionSearchResponse {
+    records: DataRecord[];
+    cursor?: string;
+}
+export interface DataCollectionFindByIdRequest extends DataCollectionMethodRequest {
+    id: string;
+    udm?: string;
+}
+export interface DataCollectionFindByIdResponse {
+    record: DataRecord;
+}
+export interface DataCollectionMatchRequest extends DataCollectionMethodRequest {
+    query: Record<string, any>;
+}
+export interface DataCollectionMatchResponse {
+    record?: DataRecord;
+}
+export interface DataCollectionCreateRequest extends DataCollectionMethodRequest {
+    fields: Record<string, any>;
+}
+export interface DataCollectionCreateResponse {
+    id: string;
+}
+export interface DataCollectionUpdateRequest extends DataCollectionMethodRequest {
+    id: string;
+    fields: Record<string, any>;
+}
+export interface DataCollectionUpdateResponse {
+    id: string;
+}
+export interface DataCollectionDeleteRequest extends DataCollectionMethodRequest {
+    id: string;
+}
+export interface DataCollectionDeleteResponse {
+}
+export interface DataCollectionSubscribeRequest extends DataCollectionMethodRequest {
+    events?: {
+        created?: boolean;
+        updated?: boolean;
+        deleted?: boolean;
+    };
+    udm?: string;
+    webhookUri: string;
+}
+export interface DataCollectionSubscribeResponse {
+    subscriptionId: string;
+    pullIntervalSeconds?: number;
+    cursor?: string;
+}
+export interface DataCollectionUpdateSubscriptionRequest extends DataCollectionSubscribeRequest {
+    subscriptionId: string;
+    cursor?: string;
+}
+export interface DataCollectionUpdateSubscriptionResponse extends Omit<DataCollectionSubscribeResponse, 'subscriptionId'> {
+}
+export interface DataCollectionUnsubscribeRequest {
+    subscriptionId: string;
+}
+export interface DataCollectionUnsubscribeResponse {
+}
+export interface DataCollectionEventsRequest extends DataCollectionMethodRequest {
+    subscriptionId: string;
+    cursor: string;
+}
+export interface DataCollectionEventsResponse {
+    events: DataCollectionEvent[];
+    cursor?: string;
+    state?: any;
+}
+export interface DataEventWebhookPayload {
+    subscriptionId: string;
+    events: DataCollectionEvent[];
+}
+export interface DataCollectionParseUnifiedFieldsRequest {
+    udm: string;
+    unifiedFields: Record<string, any>;
+}
+export interface DataCollectionParseUnifiedFieldsResponse {
+    fields: any;
+}
+export interface DataDirectoryListRequest {
+    cursor?: string;
+}
+export interface DataDirectoryListResponse {
+    locations: DataLocation[];
+    cursor?: string;
+}
+export declare const ConnectorDataLocationTypes: {
+    collection: {
+        spec: import("./collections/methods/base").ConnectorDataCollectionMethodType<unknown>;
+        recordFromFields: import("./collections/methods/base").ConnectorDataCollectionMethodType<unknown>;
+        customFieldsSchema: import("./collections/methods/base").ConnectorDataCollectionMethodType<unknown>;
+        fieldsFromApi: import("./collections/methods/base").ConnectorDataCollectionMethodType<unknown>;
+        fieldsToApi: import("./collections/methods/base").ConnectorDataCollectionMethodType<unknown>;
+        methods: {
+            list: import("./collections/methods/base").ConnectorDataCollectionMethodType<import("./collections/methods/list").DataCollectionListConfigType>;
+            findById: import("./collections/methods/base").ConnectorDataCollectionMethodType<unknown>;
+            match: import("./collections/methods/base").ConnectorDataCollectionMethodType<import("./collections/methods/match").DataCollectionMatchConfigType>;
+            search: import("./collections/methods/base").ConnectorDataCollectionMethodType<unknown>;
+            create: import("./collections/methods/base").ConnectorDataCollectionMethodType<import("./collections/methods/create").DataCollectionCreateConfigType>;
+            update: import("./collections/methods/base").ConnectorDataCollectionMethodType<import("./collections/methods/update").DataCollectionUpdateConfigType>;
+            delete: import("./collections/methods/base").ConnectorDataCollectionMethodType<unknown>;
+            find: import("./collections/methods/base").ConnectorDataCollectionMethodType<{
+                queryFields: string[];
+            }>;
+        };
+        recordToApi: import("./collections/methods/base").ConnectorDataCollectionMethodType<unknown>;
+        recordFromApi: import("./collections/methods/base").ConnectorDataCollectionMethodType<unknown>;
+        recordFromApiMapping: import("./collections/methods/base").ConnectorDataCollectionMethodType<unknown>;
+        recordFromApiCode: import("./collections/methods/base").ConnectorDataCollectionMethodType<unknown>;
+        fieldsToApiMapping: import("./collections/methods/base").ConnectorDataCollectionMethodType<unknown>;
+        fieldsToApiCode: import("./collections/methods/base").ConnectorDataCollectionMethodType<unknown>;
+    };
+    directory: {
+        spec: import("./directories/methods/base").ConnectorDataDirectoryMethodType<unknown>;
+        methods: {
+            list: import("./directories/methods/base").ConnectorDataDirectoryMethodType<unknown>;
+        };
+    };
+};
+export type ConnectorDataLocation = ConnectorDataCollection | ConnectorDataDirectory;
+export {};

package/dist/dts/connectors/data-locations/utils.d.ts

@@ -0,0 +1,17 @@
+import { DataSchema } from '../../data-schema';
+import { ConnectorDataLocation, DataCollectionSpec, DataLocationPointer } from '.';
+export declare function getDataLocationMethodPath(locationKey: any, methodKey: any): string;
+export declare function dataLocationParametersMatch({ locationParameters, targetParameters, }: {
+    locationParameters: Record<string, any>;
+    targetParameters: Record<string, any>;
+}): boolean;
+export declare function parseDataLocationPath(path: string): DataLocationPointer;
+export declare function parseDataLocationPath(path: string | undefined): DataLocationPointer | undefined;
+export declare function makeDataLocationPath(pointer: DataLocationPointer): string;
+export declare function makeDataLocationPath(pointer: DataLocationPointer | undefined): string | undefined;
+export declare function makeDataLocationOperationPath(collectionPath: string, operation: string): string;
+export declare function isSameDataLocation(location1: DataLocationPointer, location2: DataLocationPointer): boolean;
+export declare function isDataLocationMethodSupported(location: ConnectorDataLocation, methodKey: string): boolean;
+export declare function getDataCollectionCreateFields(spec: DataCollectionSpec): DataSchema | undefined;
+export declare function getDataCollectionUpdateFields(spec: DataCollectionSpec): DataSchema | undefined;
+export declare function getWritableFieldsSchema(spec: DataCollectionSpec): DataSchema | undefined;

package/dist/dts/connectors/data-locations/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dts/connectors/data-records.d.ts

@@ -0,0 +1,7 @@
+import { DataSchema } from '../data-schema';
+export declare const DATA_RECORD_SCHEMA: DataSchema;
+export declare function makeDataRecordSchema({ fieldsSchema, udm, rawFieldsSchema, }: {
+    fieldsSchema?: DataSchema;
+    udm?: string;
+    rawFieldsSchema?: DataSchema;
+}): DataSchema;

package/dist/dts/connectors/events/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

package/dist/dts/connectors/events/types.d.ts

@@ -0,0 +1,36 @@
+import { DataSchema } from '../../data-schema';
+import { ConnectorMethodImplementation, ConnectorMethodImplementationType } from '../methods';
+export declare enum ConnectorEventImplementationType {
+    GlobalWebhook = "global-webhook",
+    Webhook = "webhook"
+}
+interface ConnectorEventHandlerMethodSpec {
+    supportedImplementationTypes: ConnectorMethodImplementationType[];
+    isRequired: boolean;
+}
+export declare const ConnectorEventHandlerMethods: Record<ConnectorEventImplementationType, Record<string, ConnectorEventHandlerMethodSpec>>;
+export interface ConnectorEventHandler {
+    key: string;
+    name: string;
+    description?: string;
+    parametersSchema?: DataSchema;
+    implementationType: ConnectorEventImplementationType;
+    schema?: DataSchema;
+    methods: Record<string, ConnectorMethodImplementation>;
+}
+export interface ConnectorEventSpec {
+    key: string;
+    name: string;
+    description?: string;
+    parametersSchema?: DataSchema;
+    schema?: DataSchema;
+}
+export interface ConnectorEventListItem {
+    key: string;
+    name: string;
+}
+export interface ConnectorEventGlobalWebhookGetEventSelectorResponse {
+    globalWebhookKey: string;
+    globalWebhookEventSelector: string;
+}
+export {};

package/dist/dts/connectors/global-webhooks/index.d.ts

@@ -0,0 +1 @@
+export * from './types';

package/dist/dts/connectors/global-webhooks/types.d.ts

@@ -0,0 +1,33 @@
+import { ConnectorMethodImplementation } from '../methods';
+export interface ConnectorGlobalWebhookHandler {
+    key: string;
+    methods: {
+        handle: ConnectorMethodImplementation;
+    };
+}
+export interface ConnectorGlobalWebhookSpec {
+    key: string;
+}
+export interface ConnectorGlobalWebhookHandleRequest {
+    query: Record<string, string>;
+    data: any;
+    headers: Record<string, string>;
+    parameters: unknown;
+}
+export interface ConnectorGlobalWebhookHandleResponse {
+    events: Array<{
+        payload: any;
+        selector: string;
+    }>;
+    response?: {
+        headers?: Record<string, string>;
+        data?: any;
+        status?: number;
+    };
+}
+export interface ConnectorGlobalWebhookListItem {
+    key: string;
+    name: string;
+    description?: string;
+    uri?: string;
+}

package/dist/dts/connectors/graphql-api.d.ts

@@ -0,0 +1,17 @@
+import { HttpRequestMethod } from '../http-requests';
+export interface GraphqlApiClientInput {
+    path: string;
+    method: HttpRequestMethod;
+    query: string;
+}
+export interface GraphQLApiMapping {
+    path: string;
+    operationType: 'query' | 'mutation';
+    requestMapping: GraphQLFieldMapping[];
+    responseMapping?: any;
+}
+export interface GraphQLFieldMapping {
+    field: string;
+    args?: Record<string, any>;
+    subFields?: GraphQLFieldMapping[];
+}

package/dist/dts/connectors/index.d.ts

@@ -0,0 +1,13 @@
+export * from './auth';
+export * from './constants';
+export * from './data-locations';
+export * from './data-records';
+export * from './methods';
+export * from './openapi';
+export * from './operations';
+export * from './rest-api';
+export * from './types';
+export * from './udm';
+export * from './graphql-api';
+export * from './global-webhooks';
+export * from './events';