@membranehq/sdk 0.1.0

package/dist/dts/connections/accessors.d.ts

@@ -0,0 +1,88 @@
+import { CreateConnectionRequest, FindConnectionsQuery, UpdateConnectionRequest } from './api';
+import { ElementInstanceListAccessor } from '../accessors';
+import { ConnectionLevelActionAccessor, ConnectionLevelActionsAccessor } from '../actions';
+import { IntegrationAppApiClient } from '../api-client';
+import { DataCollectionCreateRequest, DataCollectionCreateResponse, DataCollectionDeleteRequest, DataCollectionDeleteResponse, DataCollectionFindByIdRequest, DataCollectionFindByIdResponse, DataCollectionListRequest, DataCollectionListResponse, DataCollectionMatchRequest, DataCollectionMatchResponse, DataCollectionSearchRequest, DataCollectionSearchResponse, DataCollectionSpec, DataCollectionUpdateRequest, DataCollectionUpdateResponse, DataDirectoryListRequest, DataDirectoryListResponse } from '../connectors';
+import { OperationRunRequest, OperationRunResponse, OperationSpec } from '../connectors/operations/types';
+import { ConnectionLevelDataSourceAccessor, ConnectionLevelDataSourcesAccessor } from '../data-sources';
+import { ConnectionLevelFieldMappingAccessor, ConnectionLevelFieldMappingsAccessor } from '../field-mappings';
+import { ConnectionLevelFlowAccessor, ConnectionLevelFlowsAccessor } from '../flows';
+import { OpenConfigurationOptions } from '../iframe';
+import { InstanceKeyQuery } from '../integration-elements/common';
+import { Connection } from '.';
+export declare class ConnectionsAccessor extends ElementInstanceListAccessor<Connection, FindConnectionsQuery> {
+    constructor(client: IntegrationAppApiClient);
+    create(data: CreateConnectionRequest): Promise<Connection>;
+}
+export declare class ConnectionAccessor {
+    client: IntegrationAppApiClient;
+    connectionSelector: string;
+    constructor(client: IntegrationAppApiClient, connectionSelector: string);
+    get actions(): ConnectionLevelActionsAccessor;
+    action(actionSelector: string, query?: InstanceKeyQuery): ConnectionLevelActionAccessor;
+    get flows(): ConnectionLevelFlowsAccessor;
+    flow(flowSelector: string, query?: InstanceKeyQuery): ConnectionLevelFlowAccessor;
+    get dataSources(): ConnectionLevelDataSourcesAccessor;
+    dataSource(dataSourceSelector: string, query?: InstanceKeyQuery): ConnectionLevelDataSourceAccessor;
+    get fieldMappings(): ConnectionLevelFieldMappingsAccessor;
+    fieldMapping(fieldMappingSelector: string, query?: InstanceKeyQuery): ConnectionLevelFieldMappingAccessor;
+    get(query?: {
+        includeSecrets?: boolean;
+    }): Promise<Connection>;
+    patch(data: UpdateConnectionRequest): Promise<Connection>;
+    put(data: UpdateConnectionRequest): Promise<Connection>;
+    archive(): Promise<void>;
+    request(path: string, data?: any): Promise<any>;
+    get proxy(): ConnectionProxy;
+    operation(key: string): ConnectionOperationAccessor;
+    dataCollection(key: string, parameters?: Record<string, any>): ConnectionDataCollectionAccessor;
+    dataDirectory(key: string, parameters?: Record<string, any>): ConnectionDataDirectoryAccessor;
+    reconnect({ parameters, authOptionKey, }?: {
+        parameters?: any;
+        authOptionKey?: string;
+    }): Promise<Connection | undefined>;
+    openReconnectUI({}?: OpenConfigurationOptions): Promise<void>;
+    refreshCredentials(): Promise<void>;
+    getPath(subpath?: string, query?: Record<string, any>): string;
+}
+export declare class ConnectionOperationAccessor {
+    client: IntegrationAppApiClient;
+    connectionAccessor: ConnectionAccessor;
+    key: string;
+    constructor(client: IntegrationAppApiClient, connectionAccessor: ConnectionAccessor, key: string);
+    get(): Promise<OperationSpec>;
+    run(request?: OperationRunRequest): Promise<OperationRunResponse>;
+}
+export declare class ConnectionDataDirectoryAccessor {
+    client: IntegrationAppApiClient;
+    connectionAccessor: ConnectionAccessor;
+    key: string;
+    parameters: Record<string, any>;
+    constructor(client: IntegrationAppApiClient, connectionAccessor: ConnectionAccessor, key: string, parameters: Record<string, any>);
+    list(request?: DataDirectoryListRequest): Promise<DataDirectoryListResponse>;
+}
+export declare class ConnectionDataCollectionAccessor {
+    client: IntegrationAppApiClient;
+    connectionAccessor: ConnectionAccessor;
+    key: string;
+    parameters: Record<string, any>;
+    constructor(client: IntegrationAppApiClient, connectionAccessor: ConnectionAccessor, key: string, parameters: Record<string, any>);
+    get(): Promise<DataCollectionSpec>;
+    findById(request?: DataCollectionFindByIdRequest): Promise<DataCollectionFindByIdResponse>;
+    list(request?: DataCollectionListRequest): Promise<DataCollectionListResponse>;
+    search(request?: DataCollectionSearchRequest): Promise<DataCollectionSearchResponse>;
+    match(request?: DataCollectionMatchRequest): Promise<DataCollectionMatchResponse>;
+    create(request?: DataCollectionCreateRequest): Promise<DataCollectionCreateResponse>;
+    update(request?: DataCollectionUpdateRequest): Promise<DataCollectionUpdateResponse>;
+    delete(request?: DataCollectionDeleteRequest): Promise<DataCollectionDeleteResponse>;
+}
+export declare class ConnectionProxy {
+    private connection;
+    constructor(connection: ConnectionAccessor);
+    get(path: string): Promise<any>;
+    post(path: string, data?: any): Promise<any>;
+    put(path: string, data?: any): Promise<any>;
+    patch(path: string, data?: any): Promise<any>;
+    delete(path: string): Promise<any>;
+    private getProxyPath;
+}

package/dist/dts/connections/api.d.ts

@@ -0,0 +1,27 @@
+import { PaginationQuery, PaginationResponse } from '../entity-repository';
+import { Connection } from '.';
+export interface FindConnectionsQuery extends PaginationQuery {
+    userId?: string;
+    isTest?: boolean;
+    integrationKey?: string;
+    integrationId?: string;
+    includeArchived?: boolean;
+}
+export declare class CreateConnectionRequest {
+    name: string;
+    integrationId: string;
+    credentials?: string;
+}
+export declare class UpdateConnectionRequest {
+    name?: string;
+    credentials?: string;
+    accessToken?: string;
+}
+export declare class FindConnectionsResponse extends PaginationResponse<Connection> {
+}
+export interface ConnectionSelector {
+    id?: string;
+    integrationKey?: string;
+    integrationId?: string;
+    connectionId?: string;
+}

package/dist/dts/connections/create-or-update-connection.d.ts

@@ -0,0 +1,14 @@
+import { ConnectorSpec } from '../connectors';
+import { Connection } from './types';
+export declare function createOrUpdateConnection(options?: {
+    authOptionKey?: string;
+    name?: string;
+    parameters?: any;
+    integrationId?: string;
+    connectionId?: string;
+    connectorSpec?: ConnectorSpec;
+    allowMultipleConnections?: boolean;
+    token: string;
+    apiUri: string;
+    redirectUri?: string;
+}): Promise<Connection | undefined>;

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

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

package/dist/dts/connections/types.d.ts

@@ -0,0 +1,52 @@
+import { ConnectorUiSpec, ConnectorDataUdmSpec, ConnectorDataSpec, ConnectorSpec } from '../connectors/types';
+import { ErrorData } from '../errors';
+import { Integration } from '../integrations/types';
+import { User } from '../users';
+export interface ConnectionRequest {
+    path: any;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    pathParameters?: Record<string, string>;
+    headers?: Record<string, string>;
+    query?: Record<string, string>;
+    data?: any;
+}
+export declare class Connection {
+    id: string;
+    name: string;
+    userId: string;
+    user?: User;
+    disconnected?: boolean;
+    error?: ErrorData;
+    integrationId: string;
+    integration?: Integration;
+    credentials?: unknown;
+    parameters?: unknown;
+    connectorParameters?: unknown;
+    accessToken?: string;
+    refreshToken?: string;
+    createdAt: string;
+    updatedAt: string;
+    archivedAt?: string;
+}
+export interface ConnectionSpec extends ConnectorSpec {
+}
+export type ConnectionUiSpec = ConnectorUiSpec;
+export type ConnectionUdmSpec = ConnectorDataUdmSpec;
+export type ConnectionDataSpec = ConnectorDataSpec;
+export declare class ConnectionSpec {
+    constructor(opts: ConnectionSpec);
+}
+export type ConnectionMessagePayload = {
+    source: string;
+    requestId: string;
+} & ({
+    type: 'newConnectionCreated';
+    connection: Connection;
+    error?: never;
+    errorData?: never;
+} | {
+    type: 'newConnectionFailure';
+    connection?: never;
+    error: string;
+    errorData?: ErrorData;
+});

package/dist/dts/connector-copilot/index.d.ts

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

package/dist/dts/connector-copilot/types.d.ts

@@ -0,0 +1,160 @@
+import { ErrorData } from '../errors';
+export declare enum ConnectorCopilotSuggestionType {
+    AuthType = "auth-type",
+    AuthImplementation = "auth-implementation",
+    AuthConnectionParameters = "auth-connection-parameters",
+    AuthApiClient = "auth-api-client",
+    DataCollection = "data-collection",
+    DataCollectionOperationApiRequests = "data-location-operation-api-requests",
+    DataCollectionOperationApiRequestMapping = "data-location-operation-api-request-mapping",
+    DataCollectionFieldsSchema = "data-location-fields-schema",
+    UdmList = "udm-list",
+    UdmFieldsMapping = "udm-fields-mapping",
+    UdmFieldsMappingToCollection = "udm-fields-mapping-to-collection",
+    UdmFieldsMappingFromCollection = "udm-fields-mapping-from-collection"
+}
+export interface ConnectorCopilotSuggestion {
+    id?: string;
+    type: ConnectorCopilotSuggestionType;
+    dataCollectionKey?: string;
+    title?: string;
+    description?: string;
+    parameters?: Record<string, any>;
+    hash?: string;
+    action?: ConnectorCopilotSuggestionAction;
+    actions?: ConnectorCopilotSuggestionAction[];
+}
+type ConnectorCopilotSuggestionActionType = 'patch' | 'put' | 'patch-data-schema' | 'patch-field-mapping';
+export interface ConnectorCopilotSuggestionAction {
+    type: ConnectorCopilotSuggestionActionType;
+    path: string;
+    locator?: string;
+    data: any;
+    format?: 'value' | 'fields' | 'schema';
+    schema?: any;
+    variablesSchema?: any;
+    parameters?: any;
+}
+export declare enum ConnectorCopilotFileChunkTopicKey {
+    AuthType = "auth-type",
+    AuthImplementation = "auth-implementation",
+    AuthConnectionParameters = "auth-connection-parameters",
+    AuthApiClient = "auth-api-client"
+}
+export declare enum CopilotTaskType {
+    GenerateAuthType = "generate-auth-type",
+    GenerateOAuthConfiguration = "generate-oauth-configuration",
+    GenerateAuthConnectionParameters = "generate-auth-connection-parameters",
+    GenerateAuthApiClient = "generate-auth-api-client",
+    GenerateDataCollections = "generate-data-collections",
+    GenerateDataCollectionRecordFromFields = "generate-data-collection-record-from-fields",
+    GenerateDataCollectionOperationApiRequests = "generate-data-collection-operation-api-requests",
+    GenerateDataCollectionOperationApiRequestMapping = "generate-data-collection-operation-api-request-mapping",
+    GenerateDataCollectionFieldsSchema = "generate-data-collection-fields-schema",
+    GenerateUdmList = "generate-udm-list",
+    GenerateUdmFieldsMapping = "generate-udm-fields-mapping"
+}
+export declare enum CopilotTaskStatus {
+    Pending = "pending",
+    Running = "running",
+    Completed = "completed",
+    Failed = "failed"
+}
+export interface CopilotTask<ParameterClass = unknown> {
+    id: string;
+    name: string;
+    type: CopilotTaskType;
+    parameters: ParameterClass;
+    status: CopilotTaskStatus;
+    startedTimestamp: number;
+    endedTimestamp: number;
+    error: ErrorData;
+}
+export declare enum CopilotActionType {
+    PatchConnectorFile = "patch",
+    PutConnectorFile = "put",
+    PatchConnectorDataSchema = "patch-data-schema",
+    PatchConnectorFieldMapping = "patch-field-mapping",
+    SetConnectorAuthType = "set-connector-auth-type"
+}
+export declare enum CopilotActionStatus {
+    Suggested = "suggested",
+    Executed = "executed",
+    Rejected = "rejected"
+}
+export interface CopilotAction {
+    id: string;
+    copilotTaskId: string;
+    type: CopilotActionType;
+    status: CopilotActionStatus;
+    name: string;
+    description?: string;
+    parameters?: unknown;
+    hash?: string;
+    references?: CopilotActionReference[];
+}
+export declare enum CopilotActivityType {
+    Task = "task"
+}
+export interface CopilotActivityDataTask {
+    taskId: string;
+}
+export interface CopilotActivity<DataClass = unknown> {
+    type: CopilotActivityType;
+    text: string;
+    data: DataClass;
+    scopes: string[];
+    timestamp: number;
+}
+export interface CopilotActionReference {
+    id: string;
+    snippet: string;
+    quotes?: string[];
+    file: {
+        name: string;
+        sourceUri?: string;
+    };
+}
+export declare const CopilotActivityScope: {
+    connector: (connectorId: string) => CopilotActivityScopeConnector;
+};
+declare class CopilotActivityScopeConnector {
+    private connectorId;
+    constructor(connectorId: string);
+    auth: () => CopilotActivityScopeConnectorAuth;
+    data: (key?: string) => CopilotActivityScopeConnectorData;
+    udm: (key?: string) => CopilotActivityScopeConnectorUdm;
+    toString(): string;
+}
+declare class CopilotActivityScopeConnectorAuth {
+    private connectorScope;
+    constructor(connectorScope: CopilotActivityScopeConnector);
+    toString(): string;
+}
+declare class CopilotActivityScopeConnectorData {
+    private connectorScope;
+    private dataCollectionKey;
+    constructor(connectorScope: CopilotActivityScopeConnector, dataCollectionKey: string | undefined);
+    method: (key: string) => CopilotActivityScopeConnectorDataMethod;
+    toString(): string;
+}
+declare class CopilotActivityScopeConnectorDataMethod {
+    private collectionScope;
+    private methodKey;
+    constructor(collectionScope: CopilotActivityScopeConnectorData, methodKey: string);
+    toString(): string;
+}
+declare class CopilotActivityScopeConnectorUdm {
+    private connectorScope;
+    private key?;
+    constructor(connectorScope: CopilotActivityScopeConnector, key?: string | undefined);
+    collection: (key: string) => CopilotActivityScopeConnectorUdmCollection;
+    toString(): string;
+}
+declare class CopilotActivityScopeConnectorUdmCollection {
+    private udmScope;
+    private key;
+    constructor(udmScope: CopilotActivityScopeConnectorUdm, key: string);
+    toString(): string;
+}
+export {};

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

@@ -0,0 +1,171 @@
+import { ConnectorSpec } from './types';
+import { DataSchema } from '../data-schema';
+import { ConnectorMethodImplementation, ConnectorMethodImplementationBase, ConnectorMethodImplementationType } from './methods';
+export declare const CONNECTOR_AUTH_TYPES: readonly ["integration-app-token", "oauth2", "oauth1", "client-credentials", "proxy"];
+export type ConnectorAuthType = (typeof CONNECTOR_AUTH_TYPES)[number];
+export type ConnectorAuthSpec = {
+    title?: string;
+    description?: string;
+    type: ConnectorAuthType;
+    ui?: {
+        schema?: DataSchema;
+        helpUri?: string;
+    };
+};
+export interface ConnectorAuthHandlerBase extends ConnectorAuthSpec {
+    title?: string;
+    type: ConnectorAuthType;
+    credentialsSchema?: DataSchema;
+    customCredentialsSchema?: DataSchema;
+    makeApiClient?: ConnectorMethodImplementationBase;
+    refreshCredentials?: ConnectorMethodImplementationBase;
+    test?: ConnectorMethodImplementationBase;
+    enabled?: any;
+}
+interface ConnectorAuthMethodArgs {
+    connectorSpec?: ConnectorSpec;
+    authOptionKey?: string;
+}
+interface ConnectorAuthMethodType {
+    authTypes?: ConnectorAuthType[];
+    fileKeys?: string[];
+    getInputSchema?: (args: ConnectorAuthMethodArgs) => DataSchema | undefined;
+    getOutputSchema?: (args: ConnectorAuthMethodArgs) => DataSchema | undefined;
+    supportedImplementationTypes: ConnectorMethodImplementationType[];
+    isRequired: boolean;
+}
+export declare const ConnectorAuthMethodTypes: Record<string, ConnectorAuthMethodType>;
+export interface ConnectorAuthOAuth2 extends ConnectorAuthHandlerBase {
+    type: 'oauth2';
+    getOAuthConfig?: ConnectorMethodImplementation;
+    getTokenData?: ConnectorMethodImplementation;
+    getCredentialsFromAccessTokenResponse?: ConnectorMethodImplementation;
+    getCredentialsFromRefreshTokenResponse?: ConnectorMethodImplementation;
+    oAuthConfig?: ConnectorMethodImplementation;
+}
+export interface ConnectorAuthOAuth1 extends ConnectorAuthHandlerBase {
+    type: 'oauth1';
+    getOAuthConfig?: ConnectorMethodImplementation;
+}
+export interface ConnectorAuthClientCredentials extends ConnectorAuthHandlerBase {
+    type: 'client-credentials';
+    getCredentialsFromConnectionParameters?: ConnectorMethodImplementationBase;
+}
+export interface ConnectorAuthProxy extends ConnectorAuthHandlerBase {
+    type: 'proxy';
+    proxyKey: string;
+}
+export interface ConnectorAuthIntegrationAppToken extends ConnectorAuthHandlerBase {
+    type: 'integration-app-token';
+}
+export type ConnectorAuth = (ConnectorAuthOAuth2 | ConnectorAuthOAuth1 | ConnectorAuthClientCredentials | ConnectorAuthIntegrationAppToken | ConnectorAuthProxy) & {
+    options?: {
+        [key: string]: ConnectorAuthOAuth2 | ConnectorAuthOAuth1 | ConnectorAuthClientCredentials | ConnectorAuthIntegrationAppToken | ConnectorAuthProxy;
+    };
+};
+export interface ConnectorAuthOAuth2Config {
+    clientId: any;
+    clientSecret: any;
+    authorizeUri: any;
+    tokenUri: any;
+    scopes?: any;
+    clientAuthLocation?: 'body' | 'headers';
+    noRefreshToken?: boolean;
+    skipPkce?: boolean;
+    skipClientAuthInBody?: boolean;
+    skipClientAuthInHeaders?: boolean;
+    extra?: Record<string, any>;
+}
+export type ConnectorAuthOAuthConfig = ConnectorAuthOAuth2Config;
+export interface ConnectorAuthOAuth1Config {
+    consumerKey: any;
+    consumerSecret: any;
+    requestTokenUri: any;
+    authorizeUri: any;
+    tokenUri: any;
+    extra?: Record<string, any>;
+}
+export declare const OAUTH_CONFIG_SCHEMA: {
+    type: string;
+    properties: {
+        clientId: {
+            type: string;
+        };
+        clientSecret: {
+            type: string;
+        };
+        authorizeUri: {
+            type: string;
+            description: string;
+        };
+        tokenUri: {
+            type: string;
+            description: string;
+        };
+        scopes: {
+            type: string;
+            items: {
+                type: string;
+            };
+        };
+        clientAuthLocation: {
+            type: string;
+            enum: string[];
+            default: string;
+            description: string;
+        };
+        noRefreshToken: {
+            type: string;
+            description: string;
+        };
+        skipPkce: {
+            type: string;
+            description: string;
+        };
+        extra: {
+            type: string;
+            additionalProperties: boolean;
+            description: string;
+        };
+        skipClientAuthInBody: {
+            type: string;
+            description: string;
+        };
+        skipClientAuthInHeader: {
+            type: string;
+            description: string;
+        };
+    };
+};
+export declare const OAUTH1_CONFIG_SCHEMA: {
+    type: string;
+    properties: {
+        consumerKey: {
+            type: string;
+        };
+        consumerSecret: {
+            type: string;
+        };
+        requestTokenUri: {
+            type: string;
+        };
+        authorizeUri: {
+            type: string;
+        };
+        tokenUri: {
+            type: string;
+        };
+        scopes: {
+            type: string;
+            items: {
+                type: string;
+            };
+        };
+        extra: {
+            type: string;
+            additionalProperties: boolean;
+            description: string;
+        };
+    };
+};
+export {};

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

@@ -0,0 +1,5 @@
+export declare const CONNECTOR_DATA_DIR = "data";
+export declare const CONNECTOR_OPERATIONS_DIR = "operations";
+export declare const CONNECTOR_DOCS_DIR = "docs";
+export declare const CONNECTOR_GLOBAL_WEBHOOKS_DIR = "global-webhooks";
+export declare const CONNECTOR_EVENTS_DIR = "events";

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

@@ -0,0 +1,10 @@
+import { DataLocationMixin } from './types';
+import { DataSchema } from '../../data-schema';
+export interface ConnectorDataLocationBase {
+    type: 'collection' | 'directory';
+    key: string;
+    name: string;
+    parametersSchema?: DataSchema;
+    extends?: DataLocationMixin[];
+    relatedOperationKeys?: string[];
+}

package/dist/dts/connectors/data-locations/collections/events/implementation-types/connector-event.d.ts

@@ -0,0 +1,14 @@
+import { DataSchema } from '../../../../../data-schema';
+import { ConnectorDataLocationMethod } from '../../../methods';
+import { ConnectorDataCollectionEventMethodType } from '../methods';
+export interface ConnectorEventImplementationFields {
+    implementationType: 'connector-event';
+    stateSchema?: DataSchema;
+    methods: Record<keyof typeof ConnectorEventImplementationType.methods, ConnectorDataLocationMethod>;
+}
+export declare const ConnectorEventImplementationType: {
+    methods: {
+        getEventConfig: ConnectorDataCollectionEventMethodType<ConnectorEventImplementationFields>;
+        extractEvents: ConnectorDataCollectionEventMethodType<ConnectorEventImplementationFields>;
+    };
+};

package/dist/dts/connectors/data-locations/collections/events/implementation-types/custom-pull.d.ts

@@ -0,0 +1,14 @@
+import { DataSchema } from '../../../../../data-schema';
+import { ConnectorDataLocationMethod } from '../../../methods';
+import { ConnectorDataCollectionEventMethodType } from '../methods';
+export interface CustomPullEventImplementationFields {
+    implementationType: 'custom-pull';
+    stateSchema?: DataSchema;
+    methods: Record<keyof typeof CustomPullEventImplementationType.methods, ConnectorDataLocationMethod>;
+}
+export declare const CustomPullEventImplementationType: {
+    methods: {
+        subscribe: ConnectorDataCollectionEventMethodType<CustomPullEventImplementationFields>;
+        collectEvents: ConnectorDataCollectionEventMethodType<CustomPullEventImplementationFields>;
+    };
+};

package/dist/dts/connectors/data-locations/collections/events/implementation-types/full-scan.d.ts

@@ -0,0 +1,7 @@
+export interface FullScanEventImplementationFields {
+    implementationType: 'full-scan';
+    ignoredFields?: string[];
+}
+export declare const FullScanEventImplementationType: {
+    methods: {};
+};

package/dist/dts/connectors/data-locations/collections/events/implementation-types/pull-latest-records.d.ts

@@ -0,0 +1,17 @@
+import { DataRecord } from '../../../../../data-collections';
+import { ConnectorDataLocationMethod } from '../../../methods';
+import { ConnectorDataCollectionEventMethodType } from '../methods';
+export interface PullLatestRecordsEventImplementationFields {
+    implementationType: 'pull-latest-records';
+    methods: Record<keyof typeof PullLatestRecordsEventImplementationType.methods, ConnectorDataLocationMethod>;
+}
+export interface PullLatestRecordsEventOutput {
+    records: DataRecord[];
+    cursor?: string;
+    logs?: any[];
+}
+export declare const PullLatestRecordsEventImplementationType: {
+    methods: {
+        pullLatestRecords: ConnectorDataCollectionEventMethodType<PullLatestRecordsEventImplementationFields>;
+    };
+};

package/dist/dts/connectors/data-locations/collections/events/implementation-types/webhook.d.ts

@@ -0,0 +1,18 @@
+import { DataSchema } from '../../../../../data-schema';
+import { ConnectorDataLocationMethod } from '../../../methods';
+import { ConnectorDataCollectionEventMethodType } from '../methods';
+export interface WebhookEventImplementationFields {
+    implementationType: 'webhook';
+    querySchema?: DataSchema;
+    dataSchema?: DataSchema;
+    stateSchema?: DataSchema;
+    methods: Record<keyof typeof WebhookEventImplementationType.methods, ConnectorDataLocationMethod>;
+}
+export declare const WebhookEventImplementationType: {
+    methods: {
+        subscribe: ConnectorDataCollectionEventMethodType<WebhookEventImplementationFields>;
+        unsubscribe: ConnectorDataCollectionEventMethodType<WebhookEventImplementationFields>;
+        handle: ConnectorDataCollectionEventMethodType<WebhookEventImplementationFields>;
+        refresh: ConnectorDataCollectionEventMethodType<WebhookEventImplementationFields>;
+    };
+};

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

@@ -0,0 +1,50 @@
+import { CustomPullEventImplementationFields } from './implementation-types/custom-pull';
+import { FullScanEventImplementationFields } from './implementation-types/full-scan';
+import { PullLatestRecordsEventImplementationFields } from './implementation-types/pull-latest-records';
+import { WebhookEventImplementationFields } from './implementation-types/webhook';
+export { PullLatestRecordsEventOutput } from './implementation-types/pull-latest-records';
+interface BaseConnectorDataCollectionEventImplementationFields {
+    implementationType: keyof typeof ConnectorDataCollectionEventImplementationType;
+}
+export type ConnectorDataCollectionEvent<ImplementationFields = BaseConnectorDataCollectionEventImplementationFields> = {
+    inheritedFromPath?: string[];
+    isIdOnly?: boolean;
+} & ImplementationFields;
+export type ConnectorDataCollectionEventWebhook = ConnectorDataCollectionEvent<WebhookEventImplementationFields>;
+export type ConnectorDataCollectionEventPullLatestRecords = ConnectorDataCollectionEvent<PullLatestRecordsEventImplementationFields>;
+export type ConnectorDataCollectionEventCustomPull = ConnectorDataCollectionEvent<CustomPullEventImplementationFields>;
+export type ConnectorDataCollectionEventFullScan = ConnectorDataCollectionEvent<FullScanEventImplementationFields>;
+export declare const ConnectorDataCollectionEventImplementationType: {
+    webhook: {
+        methods: {
+            subscribe: import("./methods").ConnectorDataCollectionEventMethodType<WebhookEventImplementationFields>;
+            unsubscribe: import("./methods").ConnectorDataCollectionEventMethodType<WebhookEventImplementationFields>;
+            handle: import("./methods").ConnectorDataCollectionEventMethodType<WebhookEventImplementationFields>;
+            refresh: import("./methods").ConnectorDataCollectionEventMethodType<WebhookEventImplementationFields>;
+        };
+    };
+    'pull-latest-records': {
+        methods: {
+            pullLatestRecords: import("./methods").ConnectorDataCollectionEventMethodType<PullLatestRecordsEventImplementationFields>;
+        };
+    };
+    'custom-pull': {
+        methods: {
+            subscribe: import("./methods").ConnectorDataCollectionEventMethodType<CustomPullEventImplementationFields>;
+            collectEvents: import("./methods").ConnectorDataCollectionEventMethodType<CustomPullEventImplementationFields>;
+        };
+    };
+    'connector-event': {
+        methods: {
+            getEventConfig: import("./methods").ConnectorDataCollectionEventMethodType<import("./implementation-types/connector-event").ConnectorEventImplementationFields>;
+            extractEvents: import("./methods").ConnectorDataCollectionEventMethodType<import("./implementation-types/connector-event").ConnectorEventImplementationFields>;
+        };
+    };
+    'full-scan': {
+        methods: {};
+    };
+};
+export type ConnectorDataCollectionEventType = 'created' | 'updated' | 'deleted';
+export type ConnectorDataCollectionEventImplementationTypeKey = keyof typeof ConnectorDataCollectionEventImplementationType;
+export declare function getEventMethodFileKey(eventType: ConnectorDataCollectionEventType, eventImplementationType: ConnectorDataCollectionEventImplementationTypeKey, methodKey: string): string | undefined;
+export declare function getAllEventMethodFilePaths(eventType: ConnectorDataCollectionEventType | 'all', eventImplementationType: ConnectorDataCollectionEventImplementationTypeKey, methodKey: string): (string | null | undefined)[];