@membranehq/sdk 0.3.0 → 0.5.0

package/dist/dts/workspace-elements/base/actions/types.d.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { ActionType } from './action-types';
+import { DataSchema } from '../../../data-schema';
+export declare const BaseAction: z.ZodObject<{
+    id: z.ZodString;
+    key: z.ZodString;
+    name: z.ZodString;
+    revision: z.ZodString;
+    integrationId: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodOptional<z.ZodString>;
+    parentRevision: z.ZodOptional<z.ZodString>;
+    isCustomized: z.ZodOptional<z.ZodBoolean>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    archivedAt: z.ZodOptional<z.ZodString>;
+    type: z.ZodNativeEnum<typeof ActionType>;
+    inputSchema: z.ZodOptional<z.ZodType<DataSchema, z.ZodTypeDef, DataSchema>>;
+    config: z.ZodOptional<z.ZodAny>;
+    outputMapping: z.ZodOptional<z.ZodAny>;
+    customOutputSchema: z.ZodOptional<z.ZodType<DataSchema, z.ZodTypeDef, DataSchema>>;
+    defaultOutputSchema: z.ZodOptional<z.ZodType<DataSchema, z.ZodTypeDef, DataSchema>>;
+    transformedOutputSchema: z.ZodOptional<z.ZodType<DataSchema, z.ZodTypeDef, DataSchema>>;
+    outputSchema: z.ZodOptional<z.ZodType<DataSchema, z.ZodTypeDef, DataSchema>>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    type: ActionType;
+    id: string;
+    name: string;
+    revision: string;
+    integrationId?: string | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    archivedAt?: string | undefined;
+    parentId?: string | undefined;
+    parentRevision?: string | undefined;
+    isCustomized?: boolean | undefined;
+    inputSchema?: DataSchema | undefined;
+    config?: any;
+    outputMapping?: any;
+    customOutputSchema?: DataSchema | undefined;
+    defaultOutputSchema?: DataSchema | undefined;
+    transformedOutputSchema?: DataSchema | undefined;
+    outputSchema?: DataSchema | undefined;
+    dependencies?: any[] | undefined;
+}, {
+    key: string;
+    type: ActionType;
+    id: string;
+    name: string;
+    revision: string;
+    integrationId?: string | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    archivedAt?: string | undefined;
+    parentId?: string | undefined;
+    parentRevision?: string | undefined;
+    isCustomized?: boolean | undefined;
+    inputSchema?: DataSchema | undefined;
+    config?: any;
+    outputMapping?: any;
+    customOutputSchema?: DataSchema | undefined;
+    defaultOutputSchema?: DataSchema | undefined;
+    transformedOutputSchema?: DataSchema | undefined;
+    outputSchema?: DataSchema | undefined;
+    dependencies?: any[] | undefined;
+}>;
+export type BaseAction = z.infer<typeof BaseAction>;

package/dist/dts/workspace-elements/base/app-data-schema-instances/types.d.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+export declare const BaseAppDataSchemaInstance: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+} & {
+    key: z.ZodString;
+    state: z.ZodOptional<z.ZodNativeEnum<typeof import("../../types").WorkspaceElementState>>;
+    errors: z.ZodOptional<z.ZodArray<any, "many">>;
+} & {
+    appId: z.ZodString;
+    userId: z.ZodString;
+    appDataSchemaId: z.ZodString;
+    appDataSchemaRevision: z.ZodString;
+    instanceKey: z.ZodOptional<z.ZodString>;
+    schema: z.ZodOptional<z.ZodAny>;
+    error: any;
+    archivedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    id: string;
+    name: string;
+    userId: string;
+    appId: string;
+    appDataSchemaId: string;
+    appDataSchemaRevision: string;
+    error?: any;
+    state?: import("../../types").WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    instanceKey?: string | undefined;
+    schema?: any;
+    archivedAt?: string | undefined;
+}, {
+    key: string;
+    id: string;
+    name: string;
+    userId: string;
+    appId: string;
+    appDataSchemaId: string;
+    appDataSchemaRevision: string;
+    error?: any;
+    state?: import("../../types").WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    instanceKey?: string | undefined;
+    schema?: any;
+    archivedAt?: string | undefined;
+}>;
+export type BaseAppDataSchemaInstance = z.infer<typeof BaseAppDataSchemaInstance>;

package/dist/dts/workspace-elements/base/app-data-schemas/index.d.ts

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

package/dist/dts/workspace-elements/base/app-data-schemas/types.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+export declare const BaseAppDataSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+} & {
+    key: z.ZodString;
+    state: z.ZodOptional<z.ZodNativeEnum<typeof import("../../types").WorkspaceElementState>>;
+    errors: z.ZodOptional<z.ZodArray<any, "many">>;
+} & {
+    schema: z.ZodAny;
+    code: z.ZodOptional<z.ZodString>;
+    archivedAt: z.ZodOptional<z.ZodString>;
+    revision: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    id: string;
+    name: string;
+    code?: string | undefined;
+    state?: import("../../types").WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    schema?: any;
+    archivedAt?: string | undefined;
+    revision?: string | undefined;
+}, {
+    key: string;
+    id: string;
+    name: string;
+    code?: string | undefined;
+    state?: import("../../types").WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    schema?: any;
+    archivedAt?: string | undefined;
+    revision?: string | undefined;
+}>;
+export type BaseAppDataSchema = z.infer<typeof BaseAppDataSchema>;

package/dist/dts/workspace-elements/base/app-event-subscriptions/index.d.ts

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

package/dist/dts/workspace-elements/base/app-event-subscriptions/types.d.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import { DataSchema } from '../../../data-schema';
+export declare const BaseAppEventSubscription: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+} & {
+    key: z.ZodString;
+    state: z.ZodOptional<z.ZodNativeEnum<typeof import("../../types").WorkspaceElementState>>;
+    errors: z.ZodOptional<z.ZodArray<any, "many">>;
+} & {
+    revision: z.ZodString;
+    appEventTypeId: z.ZodString;
+    userId: z.ZodString;
+    instanceKey: z.ZodOptional<z.ZodString>;
+    isSubscribed: z.ZodBoolean;
+    schema: z.ZodOptional<z.ZodType<DataSchema, z.ZodTypeDef, DataSchema>>;
+    webhookUri: z.ZodString;
+    subscriptionRequest: z.ZodObject<{
+        method: z.ZodOptional<z.ZodNativeEnum<typeof import("../../../http-requests").HttpRequestMethod>>;
+        uri: z.ZodAny;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        body: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        headers?: Record<string, any> | undefined;
+        method?: import("../../../http-requests").HttpRequestMethod | undefined;
+        body?: any;
+        uri?: any;
+        query?: Record<string, any> | undefined;
+    }, {
+        headers?: Record<string, any> | undefined;
+        method?: import("../../../http-requests").HttpRequestMethod | undefined;
+        body?: any;
+        uri?: any;
+        query?: Record<string, any> | undefined;
+    }>;
+    subscriptionResponse: z.ZodOptional<z.ZodAny>;
+    archivedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    id: string;
+    name: string;
+    userId: string;
+    webhookUri: string;
+    revision: string;
+    appEventTypeId: string;
+    isSubscribed: boolean;
+    subscriptionRequest: {
+        headers?: Record<string, any> | undefined;
+        method?: import("../../../http-requests").HttpRequestMethod | undefined;
+        body?: any;
+        uri?: any;
+        query?: Record<string, any> | undefined;
+    };
+    state?: import("../../types").WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    instanceKey?: string | undefined;
+    schema?: DataSchema | undefined;
+    archivedAt?: string | undefined;
+    subscriptionResponse?: any;
+}, {
+    key: string;
+    id: string;
+    name: string;
+    userId: string;
+    webhookUri: string;
+    revision: string;
+    appEventTypeId: string;
+    isSubscribed: boolean;
+    subscriptionRequest: {
+        headers?: Record<string, any> | undefined;
+        method?: import("../../../http-requests").HttpRequestMethod | undefined;
+        body?: any;
+        uri?: any;
+        query?: Record<string, any> | undefined;
+    };
+    state?: import("../../types").WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    instanceKey?: string | undefined;
+    schema?: DataSchema | undefined;
+    archivedAt?: string | undefined;
+    subscriptionResponse?: any;
+}>;
+export type BaseAppEventSubscription = z.infer<typeof BaseAppEventSubscription>;

package/dist/dts/workspace-elements/base/app-event-types/index.d.ts

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

package/dist/dts/workspace-elements/base/app-event-types/types.d.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import { DataSchema } from '../../../data-schema';
+export declare const BaseAppEventType: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+} & {
+    key: z.ZodString;
+    state: z.ZodOptional<z.ZodNativeEnum<typeof import("../../types").WorkspaceElementState>>;
+    errors: z.ZodOptional<z.ZodArray<any, "many">>;
+} & {
+    revision: z.ZodString;
+    archivedAt: z.ZodOptional<z.ZodString>;
+    subscribeRequest: z.ZodOptional<z.ZodObject<{
+        method: z.ZodOptional<z.ZodNativeEnum<typeof import("../../../http-requests").HttpRequestMethod>>;
+        uri: z.ZodAny;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        body: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        headers?: Record<string, any> | undefined;
+        method?: import("../../../http-requests").HttpRequestMethod | undefined;
+        body?: any;
+        uri?: any;
+        query?: Record<string, any> | undefined;
+    }, {
+        headers?: Record<string, any> | undefined;
+        method?: import("../../../http-requests").HttpRequestMethod | undefined;
+        body?: any;
+        uri?: any;
+        query?: Record<string, any> | undefined;
+    }>>;
+    example: z.ZodOptional<z.ZodAny>;
+    schema: z.ZodOptional<z.ZodType<DataSchema, z.ZodTypeDef, DataSchema>>;
+    globalWebhookUri: z.ZodString;
+    userIdFormula: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    id: string;
+    name: string;
+    revision: string;
+    globalWebhookUri: string;
+    state?: import("../../types").WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    schema?: DataSchema | undefined;
+    archivedAt?: string | undefined;
+    subscribeRequest?: {
+        headers?: Record<string, any> | undefined;
+        method?: import("../../../http-requests").HttpRequestMethod | undefined;
+        body?: any;
+        uri?: any;
+        query?: Record<string, any> | undefined;
+    } | undefined;
+    example?: any;
+    userIdFormula?: any;
+}, {
+    key: string;
+    id: string;
+    name: string;
+    revision: string;
+    globalWebhookUri: string;
+    state?: import("../../types").WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    schema?: DataSchema | undefined;
+    archivedAt?: string | undefined;
+    subscribeRequest?: {
+        headers?: Record<string, any> | undefined;
+        method?: import("../../../http-requests").HttpRequestMethod | undefined;
+        body?: any;
+        uri?: any;
+        query?: Record<string, any> | undefined;
+    } | undefined;
+    example?: any;
+    userIdFormula?: any;
+}>;
+export type BaseAppEventType = z.infer<typeof BaseAppEventType>;

package/dist/dts/workspace-elements/base/connections/index.d.ts

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

package/dist/dts/workspace-elements/base/connections/types.d.ts

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+import { WorkspaceElementState } from '../../types';
+import { ConnectorUiSpec, ConnectorSpec } from '../connectors/types';
+export declare const ConnectionRequest: z.ZodObject<{
+    path: z.ZodAny;
+    method: z.ZodOptional<z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>>;
+    pathParameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    data: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    headers?: Record<string, string> | undefined;
+    method?: "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | undefined;
+    data?: any;
+    path?: any;
+    query?: Record<string, string> | undefined;
+    pathParameters?: Record<string, string> | undefined;
+}, {
+    headers?: Record<string, string> | undefined;
+    method?: "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | undefined;
+    data?: any;
+    path?: any;
+    query?: Record<string, string> | undefined;
+    pathParameters?: Record<string, string> | undefined;
+}>;
+export type ConnectionRequest = z.infer<typeof ConnectionRequest>;
+export declare const BaseConnection: z.ZodObject<{
+    id: z.ZodString;
+} & {
+    name: z.ZodString;
+    userId: z.ZodString;
+    disconnected: z.ZodOptional<z.ZodBoolean>;
+    error: any;
+    integrationId: z.ZodString;
+    credentials: z.ZodOptional<z.ZodUnknown>;
+    parameters: z.ZodOptional<z.ZodUnknown>;
+    connectorParameters: z.ZodOptional<z.ZodUnknown>;
+    accessToken: z.ZodOptional<z.ZodString>;
+    refreshToken: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    lastActiveAt: z.ZodOptional<z.ZodString>;
+    nextCredentialsRefreshAt: z.ZodOptional<z.ZodString>;
+    archivedAt: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodNativeEnum<typeof WorkspaceElementState>>;
+    errors: z.ZodOptional<z.ZodArray<any, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    userId: string;
+    integrationId: string;
+    createdAt: string;
+    updatedAt: string;
+    error?: any;
+    state?: WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    accessToken?: string | undefined;
+    credentials?: unknown;
+    parameters?: unknown;
+    connectorParameters?: unknown;
+    disconnected?: boolean | undefined;
+    refreshToken?: string | undefined;
+    lastActiveAt?: string | undefined;
+    nextCredentialsRefreshAt?: string | undefined;
+    archivedAt?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    userId: string;
+    integrationId: string;
+    createdAt: string;
+    updatedAt: string;
+    error?: any;
+    state?: WorkspaceElementState | undefined;
+    errors?: any[] | undefined;
+    accessToken?: string | undefined;
+    credentials?: unknown;
+    parameters?: unknown;
+    connectorParameters?: unknown;
+    disconnected?: boolean | undefined;
+    refreshToken?: string | undefined;
+    lastActiveAt?: string | undefined;
+    nextCredentialsRefreshAt?: string | undefined;
+    archivedAt?: string | undefined;
+}>;
+export type BaseConnection = z.infer<typeof BaseConnection>;
+export interface ConnectionSpec extends ConnectorSpec {
+}
+export type ConnectionUiSpec = ConnectorUiSpec;
+export declare class ConnectionSpec {
+    constructor(opts: ConnectionSpec);
+}

package/dist/dts/{connectors → workspace-elements/base/connectors}/auth.d.ts

@@ -1,6 +1,6 @@
-import { ConnectorSpec } from './types';
-import { DataSchema } from '../data-schema';
 import { ConnectorMethodImplementation, ConnectorMethodImplementationBase, ConnectorMethodImplementationType } from './methods';
+import { ConnectorSpec } from './types';
+import { DataSchema } from '../../../data-schema';
 export declare const CONNECTOR_AUTH_TYPES: readonly ["integration-app-token", "membrane-token", "oauth2", "oauth1", "client-credentials", "proxy"];
 export type ConnectorAuthType = (typeof CONNECTOR_AUTH_TYPES)[number];
 export type ConnectorAuthSpec = {

package/dist/dts/workspace-elements/base/connectors/events/index.d.ts

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

package/dist/dts/{connectors → workspace-elements/base/connectors}/events/types.d.ts

@@ -1,4 +1,4 @@
-import { DataSchema } from '../../data-schema';
+import { DataSchema } from '../../../../data-schema';
 import { ConnectorMethodImplementation, ConnectorMethodImplementationType } from '../methods';
 export declare enum ConnectorEventImplementationType {
     GlobalWebhook = "global-webhook",

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

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

package/dist/dts/{connectors → workspace-elements/base/connectors}/graphql-api.d.ts

@@ -1,4 +1,4 @@
-import { HttpRequestMethod } from '../http-requests';
+import { HttpRequestMethod } from '../../../http-requests';
 export interface GraphqlApiClientInput {
     path: string;
     method: HttpRequestMethod;

package/dist/dts/{connectors → workspace-elements/base/connectors}/index.d.ts

@@ -1,7 +1,5 @@
 export * from './auth';
 export * from './constants';
-export * from './data-locations';
-export * from './data-records';
 export * from './methods';
 export * from './openapi';
 export * from './operations';

package/dist/dts/{connectors → workspace-elements/base/connectors}/methods.d.ts

@@ -1,7 +1,7 @@
 import { GraphQLApiMapping } from './graphql-api';
 import { OperationMapping } from './operations';
 import { RestApiMapping } from './rest-api';
-import { DataSchema } from '../data-schema';
+import { DataSchema } from '../../../data-schema';
 export declare enum ConnectorMethodImplementationType {
     mapping = "mapping",
     operationMapping = "operation-mapping",

package/dist/dts/{connectors → workspace-elements/base/connectors}/rest-api.d.ts

@@ -1,5 +1,5 @@
 import https from 'https';
-import { HttpRequestMethod } from '../http-requests';
+import { HttpRequestMethod } from '../../../http-requests';
 export interface RestApiClientInput {
     path: string;
     method: HttpRequestMethod;

package/dist/dts/{connectors → workspace-elements/base/connectors}/types.d.ts

@@ -1,10 +1,11 @@
-import { DataSchema } from '../data-schema';
+import { z } from 'zod';
 import { ConnectorAuth } from './auth';
 import { ConnectorMethodImplementation } from './methods';
 import { ConnectorOperationHandler } from './operations';
 import { ConnectorUdmSpec } from './udm';
+import { DataSchema } from '../../../data-schema';
 export declare const CONNECTOR_CATEGORIES: readonly ["Accounting", "Ads", "Analytics", "ATS", "Communication", "CRM", "Customer Success", "Document Management", "E-Commerce", "E-Signature", "ERP", "File Storage", "HRIS", "Legal", "Marketing Automation", "Payments", "Project Management", "Sales", "Ticketing"];
-export type Connector = ConnectorSpec & {
+export type BaseConnector = ConnectorSpec & {
     id: string;
     uuid: string;
     key: string;
@@ -56,9 +57,20 @@ export interface ConnectorSpec {
     workspaceId?: string;
     data?: any;
 }
-export type MinimalConnector = {
+export declare const MinimalConnector: z.ZodObject<{
+    id: z.ZodString;
+    key: z.ZodString;
+    name: z.ZodString;
+    logoUri: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    key: string;
     id: string;
+    name: string;
+    logoUri: string;
+}, {
     key: string;
+    id: string;
     name: string;
     logoUri: string;
-};
+}>;
+export type MinimalConnector = z.infer<typeof MinimalConnector>;

package/dist/dts/{connectors → workspace-elements/base/connectors}/udm.d.ts

@@ -1,4 +1,4 @@
-import { DataLocationPointer } from './data-locations';
+import { DataLocationPointer } from '../data-collections';
 export interface ConnectorUdmListLitem {
     key: string;
 }

package/dist/dts/workspace-elements/base/customers/index.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const BaseCustomer: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    internalId: z.ZodString;
+    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    credentials: z.ZodOptional<z.ZodAny>;
+    lastActiveAt: z.ZodOptional<z.ZodString>;
+    isTest: z.ZodOptional<z.ZodBoolean>;
+    isBillable: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    internalId: string;
+    credentials?: any;
+    fields?: Record<string, any> | undefined;
+    lastActiveAt?: string | undefined;
+    isTest?: boolean | undefined;
+    isBillable?: boolean | undefined;
+}, {
+    id: string;
+    name: string;
+    internalId: string;
+    credentials?: any;
+    fields?: Record<string, any> | undefined;
+    lastActiveAt?: string | undefined;
+    isTest?: boolean | undefined;
+    isBillable?: boolean | undefined;
+}>;
+export type BaseCustomer = z.infer<typeof BaseCustomer>;

package/dist/dts/{connectors → workspace-elements/base/data-collections}/data-locations/base.d.ts

@@ -1,5 +1,5 @@
-import { DataCollectionMixin } from './schemas';
-import { DataSchema } from '../../data-schema';
+import { DataSchema } from '../../../../data-schema';
+import { DataCollectionMixin } from '../schemas';
 export interface ConnectorDataCollectionBase {
     type: 'collection' | 'directory';
     key: string;

package/dist/dts/{connectors → workspace-elements/base/data-collections}/data-locations/collections/events/implementation-types/connector-event.d.ts

@@ -1,4 +1,4 @@
-import { DataSchema } from '../../../../../data-schema';
+import { DataSchema } from '../../../../../../../data-schema';
 import { ConnectorDataCollectionMethod } from '../../../methods';
 import { ConnectorDataCollectionEventMethodType } from '../methods';
 export interface ConnectorEventImplementationFields {

package/dist/dts/{connectors → workspace-elements/base/data-collections}/data-locations/collections/events/implementation-types/custom-pull.d.ts

@@ -1,4 +1,4 @@
-import { DataSchema } from '../../../../../data-schema';
+import { DataSchema } from '../../../../../../../data-schema';
 import { ConnectorDataCollectionMethod } from '../../../methods';
 import { ConnectorDataCollectionEventMethodType } from '../methods';
 export interface CustomPullEventImplementationFields {

package/dist/dts/{connectors → workspace-elements/base/data-collections}/data-locations/collections/events/implementation-types/pull-latest-records.d.ts

@@ -1,4 +1,4 @@
-import { DataRecord } from '../../../../../data-collections';
+import { DataRecord } from '../../../..';
 import { ConnectorDataCollectionMethod } from '../../../methods';
 import { ConnectorDataCollectionEventMethodType } from '../methods';
 export interface PullLatestRecordsEventImplementationFields {

package/dist/dts/{connectors → workspace-elements/base/data-collections}/data-locations/collections/events/implementation-types/webhook.d.ts

@@ -1,4 +1,4 @@
-import { DataSchema } from '../../../../../data-schema';
+import { DataSchema } from '../../../../../../../data-schema';
 import { ConnectorDataCollectionMethod } from '../../../methods';
 import { ConnectorDataCollectionEventMethodType } from '../methods';
 export interface WebhookEventImplementationFields {

package/dist/dts/{connectors → workspace-elements/base/data-collections}/data-locations/collections/events/methods.d.ts

@@ -1,6 +1,6 @@
 import { ConnectorDataCollection } from '..';
-import { DataSchema } from '../../../../data-schema';
-import { ConnectorMethodImplementationType } from '../../../methods';
+import { DataSchema } from '../../../../../../data-schema';
+import { ConnectorMethodImplementationType } from '../../../../connectors/methods';
 import { ConnectorDataCollectionEvent } from '.';
 interface ConnectorDataCollectionEventMethodTypeArgs<ImplementationFields = unknown> {
     event: ConnectorDataCollectionEvent<ImplementationFields>;

package/dist/dts/{connectors → workspace-elements/base/data-collections}/data-locations/collections/index.d.ts

@@ -1,4 +1,4 @@
-import { DataSchema } from '../../../data-schema';
+import { DataSchema } from '../../../../../data-schema';
 import { ConnectorDataCollectionBase } from '../base';
 import { ConnectorDataCollectionMethod } from '../methods';
 import { ConnectorDataCollectionEvent } from './events';

package/dist/dts/{connectors → workspace-elements/base/data-collections}/data-locations/collections/methods/base.d.ts

@@ -1,8 +1,8 @@
 import { ConnectorDataCollection } from '..';
-import { DataCollectionSpec } from '../..';
-import { DataSchema } from '../../../../data-schema';
-import { ConnectorMethodImplementationType } from '../../../methods';
-import { ConnectorSpec } from '../../../types';
+import { DataSchema } from '../../../../../../data-schema';
+import { ConnectorMethodImplementationType } from '../../../../connectors/methods';
+import { ConnectorSpec } from '../../../../connectors/types';
+import { DataCollectionSpec } from '../../../schemas';
 import { ConnectorDataCollectionMethod } from '../../methods';
 export interface ConnectorDataCollectionMethodType<ConfigFields = unknown> {
     name?: string;

package/dist/dts/{connectors → workspace-elements/base/data-collections}/data-locations/index.d.ts

@@ -1,5 +1,3 @@
 export * from './base';
 export * from './collections';
 export * from './methods';
-export * from './schemas';
-export * from './utils';

package/dist/dts/{connectors → workspace-elements/base/data-collections}/data-locations/methods.d.ts

@@ -1,5 +1,5 @@
-import { ConnectorMethodImplementation, ConnectorMethodImplementationBase, ConnectorMethodImplementationType } from '../methods';
-import { ApiRequestSpec } from './schemas';
+import { ConnectorMethodImplementation, ConnectorMethodImplementationBase, ConnectorMethodImplementationType } from '../../connectors/methods';
+import { ApiRequestSpec } from '../schemas';
 export type ConnectorDataCollectionMethod<ConfigFields = unknown, ImplementationFields extends ConnectorMethodImplementation | ConnectorMethodImplementationBase = ConnectorMethodImplementationBase> = {
     apiRequests?: ApiRequestSpec[];
 } & ImplementationFields & ConfigFields;

package/dist/dts/{connectors → workspace-elements/base/data-collections}/data-records.d.ts

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

package/dist/dts/workspace-elements/base/data-collections/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './schemas';
+export * from './udm';
+export * from './data-records';
+export * from './data-locations';
+export * from './utils';