@membranehq/sdk 0.17.5 → 0.18.0

package/dist/index.node.mjs

@@ -3473,6 +3473,8 @@ var WorkspaceElementType;
     WorkspaceElementType["ExternalEventPull"] = "external-event-pull";
     WorkspaceElementType["Screen"] = "screen";
     WorkspaceElementType["ActionRunLogRecord"] = "action-run-log-record";
+    WorkspaceElementType["ExternalApiLogRecord"] = "external-api-log-record";
+    WorkspaceElementType["IncomingWebhookLogRecord"] = "incoming-webhook-log-record";
     WorkspaceElementType["ConnectedProduct"] = "connected-product";
 })(WorkspaceElementType || (WorkspaceElementType = {}));
 var WorkspaceEventType;
@@ -3671,6 +3673,7 @@ const ActivityLogRecord = TenantLayerElement.extend({
     id: z.string(),
     integrationId: z.string().optional(),
     connectionId: z.string().optional(),
+    externalAppId: z.string().optional(),
 });
 const WorkspaceElementSearchQuery = z.object({
     q: z.string().min(1).max(200),
@@ -4005,6 +4008,97 @@ class ConnectionSpec {
     }
 }
 
+var FunctionType;
+(function (FunctionType) {
+    FunctionType["mapping"] = "mapping";
+    FunctionType["operationMapping"] = "operation-mapping";
+    FunctionType["restApiMapping"] = "rest-api-mapping";
+    FunctionType["graphqlApiMapping"] = "graphql-api-mapping";
+    FunctionType["javascript"] = "javascript";
+})(FunctionType || (FunctionType = {}));
+const BaseFunctionDefinition = z.object({
+    type: z.enum([
+        FunctionType.mapping,
+        FunctionType.operationMapping,
+        FunctionType.restApiMapping,
+        FunctionType.graphqlApiMapping,
+        FunctionType.javascript,
+    ]),
+});
+const GenericFunctionDefinition = z
+    .object({
+    type: z.enum(['mapping', 'operation-mapping', 'rest-api-mapping', 'graphql-api-mapping', 'javascript']).optional(),
+})
+    .loose();
+
+const GraphQLFieldMappingSchema = z.lazy(() => z.object({
+    field: z.string(),
+    args: z.record(z.string(), z.any()).optional(),
+    subFields: z.array(GraphQLFieldMappingSchema).optional(),
+}));
+const GraphQLApiMappingSchema = z.object({
+    path: z.string(),
+    operationType: z.enum(['query', 'mutation']),
+    requestMapping: z.array(GraphQLFieldMappingSchema),
+    responseMapping: z.any().optional(),
+});
+const GraphqlApiMappingFunction = z.object({
+    type: z.literal(FunctionType.graphqlApiMapping),
+    mapping: GraphQLApiMappingSchema,
+});
+
+const JavascriptFunction = z.object({
+    type: z.literal(FunctionType.javascript),
+    code: z.string(),
+});
+
+const MappingSchema = z.any();
+const MappingFunction = z.object({
+    type: z.literal(FunctionType.mapping),
+    mapping: MappingSchema,
+});
+
+const OperationMappingSchema = z.object({
+    operationKey: z.string(),
+    inputMapping: z.any().optional(),
+    outputMapping: z.any().optional(),
+});
+const OperationMappingFunction = z.object({
+    type: z.literal(FunctionType.operationMapping),
+    mapping: OperationMappingSchema,
+});
+
+const RequestMappingSchema = z.object({
+    pathParameters: z.any().optional(),
+    query: z.any().optional(),
+    data: z.any().optional(),
+    headers: z.any().optional(),
+});
+const RestApiMappingSchema = z.object({
+    path: z.string(),
+    method: z.string(),
+    requestMapping: RequestMappingSchema,
+    responseMapping: z.any().optional(),
+});
+const OpenapiMappingSchema = z.object({
+    path: z.string(),
+    method: z.string(),
+    requestMapping: RequestMappingSchema,
+    responseMapping: z.any().optional(),
+});
+const RestApiMappingFunction = z.object({
+    type: z.literal(FunctionType.restApiMapping),
+    mapping: RestApiMappingSchema,
+});
+
+const FunctionDefinition = z.union([
+    MappingFunction,
+    OperationMappingFunction,
+    RestApiMappingFunction,
+    GraphqlApiMappingFunction,
+    JavascriptFunction,
+]);
+
 var ConnectorMethodImplementationType;
 (function (ConnectorMethodImplementationType) {
     ConnectorMethodImplementationType["mapping"] = "mapping";
@@ -4401,97 +4495,6 @@ const REST_API_CLIENT_SCHEMA$1 = {
     },
 };
 
-var FunctionType;
-(function (FunctionType) {
-    FunctionType["mapping"] = "mapping";
-    FunctionType["operationMapping"] = "operation-mapping";
-    FunctionType["restApiMapping"] = "rest-api-mapping";
-    FunctionType["graphqlApiMapping"] = "graphql-api-mapping";
-    FunctionType["javascript"] = "javascript";
-})(FunctionType || (FunctionType = {}));
-const BaseFunctionDefinition = z.object({
-    type: z.enum([
-        FunctionType.mapping,
-        FunctionType.operationMapping,
-        FunctionType.restApiMapping,
-        FunctionType.graphqlApiMapping,
-        FunctionType.javascript,
-    ]),
-});
-const GenericFunctionDefinition = z
-    .object({
-    type: z.enum(['mapping', 'operation-mapping', 'rest-api-mapping', 'graphql-api-mapping', 'javascript']).optional(),
-})
-    .loose();
-
-const GraphQLFieldMappingSchema = z.lazy(() => z.object({
-    field: z.string(),
-    args: z.record(z.string(), z.any()).optional(),
-    subFields: z.array(GraphQLFieldMappingSchema).optional(),
-}));
-const GraphQLApiMappingSchema = z.object({
-    path: z.string(),
-    operationType: z.enum(['query', 'mutation']),
-    requestMapping: z.array(GraphQLFieldMappingSchema),
-    responseMapping: z.any().optional(),
-});
-const GraphqlApiMappingFunction = z.object({
-    type: z.literal(FunctionType.graphqlApiMapping),
-    mapping: GraphQLApiMappingSchema,
-});
-
-const JavascriptFunction = z.object({
-    type: z.literal(FunctionType.javascript),
-    code: z.string(),
-});
-
-const MappingSchema = z.any();
-const MappingFunction = z.object({
-    type: z.literal(FunctionType.mapping),
-    mapping: MappingSchema,
-});
-
-const OperationMappingSchema = z.object({
-    operationKey: z.string(),
-    inputMapping: z.any().optional(),
-    outputMapping: z.any().optional(),
-});
-const OperationMappingFunction = z.object({
-    type: z.literal(FunctionType.operationMapping),
-    mapping: OperationMappingSchema,
-});
-
-const RequestMappingSchema = z.object({
-    pathParameters: z.any().optional(),
-    query: z.any().optional(),
-    data: z.any().optional(),
-    headers: z.any().optional(),
-});
-const RestApiMappingSchema = z.object({
-    path: z.string(),
-    method: z.string(),
-    requestMapping: RequestMappingSchema,
-    responseMapping: z.any().optional(),
-});
-const OpenapiMappingSchema = z.object({
-    path: z.string(),
-    method: z.string(),
-    requestMapping: RequestMappingSchema,
-    responseMapping: z.any().optional(),
-});
-const RestApiMappingFunction = z.object({
-    type: z.literal(FunctionType.restApiMapping),
-    mapping: RestApiMappingSchema,
-});
-
-const FunctionDefinition = z.union([
-    MappingFunction,
-    OperationMappingFunction,
-    RestApiMappingFunction,
-    GraphqlApiMappingFunction,
-    JavascriptFunction,
-]);
-
 const CONNECTOR_DATA_DIR = 'data';
 const CONNECTOR_OPERATIONS_DIR = 'operations';
 const CONNECTOR_DOCS_DIR = 'docs';
@@ -4667,369 +4670,528 @@ var DataCollectionEventType;
     DataCollectionEventType["DELETED"] = "deleted";
 })(DataCollectionEventType || (DataCollectionEventType = {}));
 
-const DataLocationMethodImplementationTypes = [
-    ConnectorMethodImplementationType.operationMapping,
-    ConnectorMethodImplementationType.restApiMapping,
-    ConnectorMethodImplementationType.graphqlApiMapping,
-    ConnectorMethodImplementationType.javascript,
-    ConnectorMethodImplementationType.notSupported,
-];
+const structuredClone$1 = (structuredClonePolyfill === null || structuredClonePolyfill === void 0 ? void 0 : structuredClonePolyfill.default) || structuredClonePolyfill;
+function isNil(value) {
+    return value == null;
+}
+function omitBy(obj, check) {
+    obj = { ...obj };
+    Object.entries(obj).forEach(([key, value]) => check(value) && delete obj[key]);
+    return obj;
+}
+function isEmptyValue(value) {
+    if (isNil(value)) {
+        return true;
+    }
+    if (typeof value === 'symbol') {
+        return true;
+    }
+    if (typeof value === 'boolean') {
+        return false;
+    }
+    if (typeof value === 'number') {
+        return isNaN(value);
+    }
+    if (typeof value === 'string') {
+        return value.trim().length === 0;
+    }
+    const tag = value.toString();
+    if (tag === '[object Map]' || tag === '[object Set]') {
+        return !value.size;
+    }
+    return typeof value === 'object' && Object.keys(value).length === 0;
+}
+const simpleUniqueId = () => {
+    return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)
+        .toString(36)
+        .padStart(11, '0')
+        .substring(0, 11);
+};
 
-const DataCollectionMethodCreate = {
-    name: 'Create',
-    description: 'Create a new data record in the collection',
-    getConfigSchema: ({ collectionSpec }) => {
-        var _a, _b;
-        const fields = Object.keys((_b = (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : {}).map(locatorToField);
-        return {
-            type: 'object',
-            properties: {
-                fields: {
-                    type: 'array',
-                    items: { type: 'string', enum: fields },
-                },
-                excludedFields: {
-                    type: 'array',
-                    items: { type: 'string', enum: fields },
-                },
-            },
-        };
-    },
-    getInputSchema: ({ collectionSpec, method, credentialsSchema }) => {
-        var _a;
-        let fieldsSchema = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema;
-        if (method === null || method === void 0 ? void 0 : method.fields) {
-            fieldsSchema = pickFieldsFromSchema(fieldsSchema, method.fields);
-        }
-        if (method === null || method === void 0 ? void 0 : method.excludedFields) {
-            fieldsSchema = excludeFieldsFromSchema(fieldsSchema, method.excludedFields);
-        }
+function getDataLocationMethodPath(locationKey, methodKey) {
+    return `data/${locationKey}/${toKebabCase(methodKey)}`;
+}
+function dataLocationParametersMatch({ locationParameters, targetParameters, }) {
+    targetParameters = typeof targetParameters === 'object' && targetParameters ? targetParameters : {};
+    locationParameters = typeof locationParameters === 'object' && locationParameters ? locationParameters : {};
+    for (const [key, value] of Object.entries(targetParameters)) {
+        if (locationParameters[key] !== value) {
+            return false;
+        }
+    }
+    return true;
+}
+function parseDataLocationPath(path) {
+    if (!path) {
+        return undefined;
+    }
+    if (path.startsWith('/')) {
+        path = path.slice(1);
+    }
+    if (!path.startsWith('data/')) {
+        throw new Error(`Invalid data location path: ${path}. It should start with "data/"`);
+    }
+    path = path.slice(5);
+    const [key, query] = path.split('?');
+    const parameters = Object.fromEntries(new URLSearchParams(query).entries());
+    return { key, parameters };
+}
+function makeDataLocationPath(pointer) {
+    var _a;
+    const normalizedPointer = normalizePointer(pointer);
+    if (normalizedPointer === null || normalizedPointer === void 0 ? void 0 : normalizedPointer.key) {
+        let path = `/data/${normalizedPointer.key}`;
+        const parameters = omitBy((_a = normalizedPointer.parameters) !== null && _a !== void 0 ? _a : {}, isNil);
+        if (Object.keys(parameters).length > 0) {
+            path += `?${new URLSearchParams(parameters).toString()}`;
+        }
+        return path;
+    }
+    else {
+        return undefined;
+    }
+}
+function normalizePointer(pointer) {
+    if (typeof pointer === 'string' && pointer.startsWith('/data/')) {
         return {
-            type: 'object',
-            properties: nonEmptyObjectProperties({
-                fields: (_a = transformVariablesWith(fieldsSchema, (locator) => `fields.${locatorToField(locator)}`)) !== null && _a !== void 0 ? _a : {
-                    type: 'object',
-                },
-                credentials: credentialsSchema,
-            }),
+            key: pointer.slice(6),
         };
-    },
-    getOutputSchema: ({}) => ({
-        type: 'object',
-        properties: {
-            id: { type: 'string' },
-        },
-    }),
-    supportedImplementationTypes: DataLocationMethodImplementationTypes,
-};
+    }
+    return pointer;
+}
+function makeDataLocationOperationPath(collectionPath, operation) {
+    const [path, query] = (collectionPath !== null && collectionPath !== void 0 ? collectionPath : '').split('?');
+    return urljoin(path, operation, query ? `?${query}` : '');
+}
+function isSameDataLocation(location1, location2) {
+    if (location1.key !== location2.key) {
+        return false;
+    }
+    const cleanParameters1 = location1.parameters && Object.keys(location1.parameters).length > 0 ? location1.parameters : undefined;
+    const cleanParameters2 = location2.parameters && Object.keys(location2.parameters).length > 0 ? location2.parameters : undefined;
+    if (!deepEqual(cleanParameters1, cleanParameters2)) {
+        return false;
+    }
+    return true;
+}
+function isDataLocationMethodSupported(location, methodKey) {
+    var _a;
+    const method = (_a = location === null || location === void 0 ? void 0 : location.methods) === null || _a === void 0 ? void 0 : _a[methodKey];
+    return method && method.implementationType !== ConnectorMethodImplementationType.notSupported;
+}
+function getDataCollectionCreateFields(spec) {
+    if (!spec)
+        return undefined;
+    if (!spec.fieldsSchema)
+        return undefined;
+    if (!spec.create)
+        return undefined;
+    let schema = excludeReadOnlyFieldsFromSchema(spec.fieldsSchema);
+    if (spec.create.fields) {
+        schema = pickFieldsFromSchema(schema, spec.create.fields);
+    }
+    if (spec.create.excludedFields) {
+        schema = excludeFieldsFromSchema(schema, spec.create.excludedFields);
+    }
+    return schema;
+}
+function getDataCollectionUpdateFields(spec) {
+    if (!spec)
+        return undefined;
+    if (!spec.fieldsSchema)
+        return undefined;
+    if (!spec.update)
+        return undefined;
+    let schema = excludeReadOnlyFieldsFromSchema(spec.fieldsSchema);
+    if (spec.update.fields) {
+        schema = pickFieldsFromSchema(schema, spec.update.fields);
+    }
+    if (spec.update.excludedFields) {
+        schema = excludeFieldsFromSchema(schema, spec.update.excludedFields);
+    }
+    return schema;
+}
+function getWritableFieldsSchema(spec) {
+    if (!spec)
+        return undefined;
+    if (!spec.fieldsSchema)
+        return undefined;
+    return mergeSchemas([getDataCollectionCreateFields(spec), getDataCollectionUpdateFields(spec)]);
+}
+function getReferenceCollectionPointerForSchema(schema) {
+    if ((schema === null || schema === void 0 ? void 0 : schema.referenceCollection) && schema.referenceCollection.key) {
+        return schema.referenceCollection;
+    }
+    else if (schema === null || schema === void 0 ? void 0 : schema.referenceCollectionPath) {
+        return parseDataLocationPath(schema.referenceCollectionPath);
+    }
+    else if (schema === null || schema === void 0 ? void 0 : schema.referenceCollectionUri) {
+        return parseDataLocationPath(schema.referenceCollectionUri);
+    }
+    else {
+        return undefined;
+    }
+}
+function getReferenceCollectionPathForSchema(schema) {
+    const pointer = getReferenceCollectionPointerForSchema(schema);
+    return makeDataLocationPath(pointer);
+}
 
-const DataCollectionMethodDelete = {
-    name: 'Delete',
-    description: 'Delete a data record from the collection by id',
-    getInputSchema: ({ collectionHandler, parameters, credentialsSchema }) => {
-        return {
-            type: 'object',
-            properties: nonEmptyObjectProperties({
-                id: {
-                    type: 'string',
-                    referenceCollection: { key: collectionHandler === null || collectionHandler === void 0 ? void 0 : collectionHandler.key, parameters },
+const FIELDS_SCHEMA$G = {
+    type: 'object',
+    properties: {
+        id: { type: 'string', readOnly: true },
+        title: { type: 'string' },
+        description: { type: 'string' },
+        type: { type: 'string' },
+        durationSeconds: { type: 'number' },
+        location: { type: 'string' },
+        isRecurrent: { type: 'boolean' },
+        participants: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    userId: { type: 'string' },
+                    contactId: { type: 'string' },
                 },
-                credentials: credentialsSchema,
-            }),
-        };
+            },
+        },
+        status: { type: 'string' },
+        contactId: {
+            type: 'string',
+            referenceUdm: 'contacts',
+        },
+        companyId: {
+            type: 'string',
+            referenceUdm: 'companies',
+        },
+        dealId: {
+            type: 'string',
+            referenceUdm: 'deals',
+        },
+        leadId: {
+            type: 'string',
+            referenceUdm: 'leads',
+        },
+        ownerId: {
+            type: 'string',
+            referenceUdm: 'users',
+        },
+        startTime: {
+            type: 'string',
+            format: 'date-time',
+        },
+        endTime: {
+            type: 'string',
+            format: 'date-time',
+        },
+        dueTime: {
+            type: 'string',
+            format: 'date-time',
+        },
+        createdTime: {
+            type: 'string',
+            format: 'date-time',
+            readOnly: true,
+        },
+        createdBy: {
+            type: 'string',
+            referenceUdm: 'users',
+            readOnly: true,
+        },
+        updatedTime: {
+            type: 'string',
+            format: 'date-time',
+            readOnly: true,
+        },
+        updatedBy: {
+            type: 'string',
+            referenceUdm: 'users',
+            readOnly: true,
+        },
     },
-    getOutputSchema: () => null,
-    supportedImplementationTypes: DataLocationMethodImplementationTypes,
 };
-
-const DataCollectionMethodFind = {
-    isDeprecated: true,
-    name: 'Find',
-    description: 'Find a list of data records in the collection',
-    getConfigSchema: ({ collectionSpec }) => {
-        var _a, _b;
-        const fields = Object.keys((_b = (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : {}).map(locatorToField);
-        return {
-            type: 'object',
-            properties: {
-                queryFields: {
-                    type: 'array',
-                    items: { type: 'string', enum: fields },
-                },
-            },
-        };
+const FallbackFieldsMap = {
+    fromActivitiesToTasks: {
+        subject: {
+            $var: 'title',
+        },
+        content: {
+            $var: 'description',
+        },
     },
-    getInputSchema: ({ collectionSpec, method, credentialsSchema }) => {
-        const queryFieldsSchema = pickFieldsFromSchema(collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema, method === null || method === void 0 ? void 0 : method.queryFields);
-        const schema = {
-            type: 'object',
-            properties: nonEmptyObjectProperties({
-                cursor: { type: 'string' },
-                credentials: credentialsSchema,
-            }),
-        };
-        if (queryFieldsSchema === null || queryFieldsSchema === void 0 ? void 0 : queryFieldsSchema.properties) {
-            schema.properties = {
-                ...schema.properties,
-                query: transformVariablesWith(queryFieldsSchema, (locator) => `query.${locatorToField(locator)}`),
-            };
-        }
-        return schema;
+    fromTasksToActivities: {
+        title: {
+            $var: 'subject',
+        },
+        description: {
+            $var: 'content',
+        },
     },
-    getOutputSchema: ({ collectionSpec }) => {
-        var _a;
-        return ({
-            type: 'object',
-            properties: {
-                records: {
-                    type: 'array',
-                    items: (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) !== null && _a !== void 0 ? _a : { type: 'object' },
-                },
-                cursor: {
-                    type: 'string',
-                },
-            },
-        });
+    fromActivitiesToNotes: {
+        content: {
+            $var: 'description',
+        },
+    },
+    fromNotesToActivities: {
+        description: {
+            $var: 'content',
+        },
+    },
+    fromActivitiesToEmails: {
+        subject: {
+            $var: 'title',
+        },
+        body: {
+            $var: 'description',
+        },
+    },
+    fromEmailsToActivities: {
+        title: {
+            $var: 'subject',
+        },
+        description: {
+            $var: 'body',
+        },
     },
-    supportedImplementationTypes: DataLocationMethodImplementationTypes,
 };
-
-const DataCollectionMethodFindById = {
-    name: 'Find by ID',
-    description: 'Find a single data record in the collection by its id',
-    getInputSchema: ({ collectionHandler, parameters, credentialsSchema }) => ({
-        type: 'object',
-        properties: nonEmptyObjectProperties({
-            id: {
-                type: 'string',
-                referenceCollection: { key: collectionHandler === null || collectionHandler === void 0 ? void 0 : collectionHandler.key, parameters },
-            },
-            credentials: credentialsSchema,
-        }),
-    }),
-    getOutputSchema: ({ collectionSpec }) => {
-        var _a;
-        return ({
-            type: 'object',
-            properties: {
-                record: (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) !== null && _a !== void 0 ? _a : { type: 'object' },
-            },
-        });
+const udm$G = {
+    singularName: 'activity',
+    pluralName: 'activities',
+    fieldsSchema: FIELDS_SCHEMA$G,
+    list: {
+        filterFields: ['type', 'companyId', 'contactId', 'dealId', 'leadId', 'ownerId'],
     },
-    supportedImplementationTypes: DataLocationMethodImplementationTypes,
+    match: {
+        fields: ['type', 'companyId', 'contactId', 'dealId', 'leadId', 'ownerId'],
+    },
+    populateFields,
+    udmFallbacks: [
+        {
+            udm: 'tasks',
+            importFields: FallbackFieldsMap.fromTasksToActivities,
+            exportFields: FallbackFieldsMap.fromActivitiesToTasks,
+        },
+        {
+            udm: 'meetings',
+        },
+        {
+            udm: 'notes',
+            importFields: FallbackFieldsMap.fromNotesToActivities,
+            exportFields: FallbackFieldsMap.fromActivitiesToNotes,
+        },
+        {
+            udm: 'emails',
+            importFields: FallbackFieldsMap.fromEmailsToActivities,
+            exportFields: FallbackFieldsMap.fromActivitiesToEmails,
+        },
+    ],
 };
+function populateFields(fields) {
+    const result = JSON.parse(JSON.stringify(fields));
+    if (!result.dueTime) {
+        result.dueTime = result.endTime || result.startTime;
+    }
+    if (!result.startTime) {
+        result.startTime = result.dueTime || result.endTime;
+    }
+    if (!result.endTime) {
+        result.endTime = result.dueTime || result.startTime;
+    }
+    return result;
+}
 
-const DataCollectionMethodList = {
-    name: 'List',
-    description: 'Return all data records from the collection',
-    getConfigSchema: ({ collectionSpec }) => {
-        var _a, _b;
-        const fields = Object.keys((_b = (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : {}).map(locatorToField);
-        return {
-            type: 'object',
-            properties: {
-                filterFields: {
-                    type: 'array',
-                    items: { type: 'string', enum: fields },
+const FIELDS_SCHEMA$F = {
+    type: 'object',
+    properties: {
+        id: { type: 'string', readOnly: true },
+        number: { type: 'string' },
+        name: { type: 'string' },
+        memo: { type: 'string' },
+        status: { type: 'string' },
+        paymentMethod: { type: 'string' },
+        supplierId: { type: 'string', referenceUdm: 'suppliers' },
+        currency: { type: 'string' },
+        payments: {
+            type: 'array',
+            items: {
+                type: 'string',
+                referenceUdm: 'payments',
+            },
+        },
+        lineItems: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    itemName: { type: 'string' },
+                    description: { type: 'string' },
+                    code: { type: 'string' },
+                    type: { type: 'string' },
+                    companyId: { type: 'string', referenceUdm: 'companies' },
+                    ledgerAccountId: { type: 'string', referenceUdm: 'ledger-accounts' },
+                    quantity: { type: 'number' },
+                    unitPrice: { type: 'number' },
+                    unitOfMeasure: { type: 'string' },
+                    purchasePrice: { type: 'number' },
+                    salesPrice: { type: 'number' },
+                    taxable: { type: 'boolean' },
+                    taxAmount: { type: 'number' },
+                    totalAmount: { type: 'number' },
                 },
             },
-        };
+        },
+        totalAmount: { type: 'number' },
+        totalTax: { type: 'number' },
+        exchangeRate: { type: 'number' },
+        totalDiscount: { type: 'number' },
+        subTotal: { type: 'number' },
+        balance: { type: 'number' },
+        ledgerAccountId: { type: 'string', referenceUdm: 'ledger-accounts' },
+        issueDate: {
+            type: 'string',
+            format: 'date-time',
+        },
+        dueDate: {
+            type: 'string',
+            format: 'date-time',
+        },
+        paidOnDate: {
+            type: 'string',
+            format: 'date-time',
+        },
+        createdTime: { type: 'string', format: 'date-time', readOnly: true },
+        createdBy: { type: 'string', referenceUdm: 'users', readOnly: true },
+        updatedTime: { type: 'string', format: 'date-time', readOnly: true },
+        updatedBy: { type: 'string', referenceUdm: 'users', readOnly: true },
     },
-    getInputSchema: ({ method, collectionSpec, credentialsSchema }) => {
-        const fieldsSchema = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema;
-        let filterSchema;
-        if (method === null || method === void 0 ? void 0 : method.filterFields) {
-            filterSchema = pickFieldsFromSchema(fieldsSchema, method.filterFields);
-        }
-        return {
-            type: 'object',
-            properties: nonEmptyObjectProperties({
-                filter: filterSchema,
-                cursor: {
-                    type: 'string',
-                    description: 'Cursor returned in response to the previous "list" request',
-                },
-                credentials: credentialsSchema,
-            }),
-        };
+};
+const udm$F = {
+    singularName: 'bill',
+    pluralName: 'bills',
+    fieldsSchema: FIELDS_SCHEMA$F,
+    list: {
+        filterFields: ['name', 'number', 'status', 'supplierId'],
     },
-    getOutputSchema: ({ collectionSpec }) => {
-        var _a;
-        return ({
-            type: 'object',
-            properties: {
-                records: {
-                    type: 'array',
-                    items: (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) !== null && _a !== void 0 ? _a : { type: 'object' },
-                },
-                cursor: {
-                    type: 'string',
-                    description: 'Cursor to request the next page of results',
-                },
-            },
-        });
+    match: {
+        fields: ['name', 'number', 'status', 'supplierId'],
     },
-    supportedImplementationTypes: DataLocationMethodImplementationTypes,
 };
 
-const DataCollectionMethodMatch = {
-    name: 'Match',
-    description: 'Find a single matching record in a data collection by a set of fields',
-    getConfigSchema: ({ collectionSpec }) => {
-        var _a, _b;
-        const fields = Object.keys((_b = (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : {}).map(locatorToField);
-        return {
-            type: 'object',
-            properties: {
-                fields: {
-                    type: 'array',
-                    items: { type: 'string', enum: fields },
-                },
-            },
-        };
-    },
-    getInputSchema: ({ collectionSpec, method, credentialsSchema }) => {
-        const fieldsSchema = pickFieldsFromSchema(collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema, method === null || method === void 0 ? void 0 : method.fields);
-        return {
-            type: 'object',
-            properties: nonEmptyObjectProperties({
-                query: transformVariablesWith(fieldsSchema !== null && fieldsSchema !== void 0 ? fieldsSchema : {}, (locator) => `query.${locatorToField(locator)}`),
-                credentials: credentialsSchema,
-            }),
-        };
-    },
-    getOutputSchema: ({ collectionSpec }) => {
-        var _a;
-        return ({
-            type: 'object',
-            properties: {
-                record: (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) !== null && _a !== void 0 ? _a : { type: 'object' },
-            },
-        });
-    },
-    supportedImplementationTypes: DataLocationMethodImplementationTypes,
-};
-
-const DataCollectionMethodSearch = {
-    name: 'Search',
-    description: 'Find data records in a collection by a string query',
-    getInputSchema: ({ credentialsSchema }) => ({
-        type: 'object',
-        properties: nonEmptyObjectProperties({
-            query: { type: 'string' },
-            cursor: { type: 'string' },
-            credentials: credentialsSchema,
-        }),
-    }),
-    getOutputSchema: ({ collectionSpec }) => {
-        var _a;
-        return ({
-            type: 'object',
-            properties: {
-                records: {
-                    type: 'array',
-                    items: (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) !== null && _a !== void 0 ? _a : { type: 'object' },
-                },
-                cursor: { type: 'string' },
-            },
-        });
+const FIELDS_SCHEMA$E = {
+    type: 'object',
+    properties: {
+        id: { type: 'string', readOnly: true },
+        fullName: { type: 'string' },
+        firstName: { type: 'string' },
+        lastName: { type: 'string' },
+        primaryEmail: { type: 'string' },
+        campaignId: {
+            type: 'string',
+            referenceUdm: 'campaigns',
+        },
+        contactId: {
+            type: 'string',
+            referenceUdm: 'contacts',
+        },
+        leadId: {
+            type: 'string',
+            referenceUdm: 'leads',
+        },
+        source: { type: 'string' },
+        status: { type: 'string' },
+        companyId: {
+            type: 'string',
+            referenceUdm: 'companies',
+        },
+        jobTitle: { type: 'string' },
+        hasOptedOutOfEmail: { type: 'boolean' },
+        createdTime: {
+            type: 'string',
+            format: 'date-time',
+        },
+        createdBy: {
+            type: 'string',
+            readOnly: true,
+            referenceUdm: 'users',
+        },
+        updatedTime: {
+            type: 'string',
+            readOnly: true,
+            format: 'date-time',
+        },
+        updatedBy: {
+            type: 'string',
+            readOnly: true,
+            referenceUdm: 'users',
+        },
     },
-    supportedImplementationTypes: DataLocationMethodImplementationTypes,
 };
-
-const DataCollectionMethodUpdate = {
-    name: 'Update',
-    description: 'Update one data record in the collection by its id',
-    getConfigSchema: ({ collectionSpec }) => {
-        var _a, _b;
-        const fields = Object.keys((_b = (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : {}).map(locatorToField);
-        return {
-            type: 'object',
-            properties: {
-                fields: {
-                    type: 'array',
-                    items: { type: 'string', enum: fields },
-                },
-                excludedFields: {
-                    type: 'array',
-                    items: { type: 'string', enum: fields },
-                },
-            },
-        };
+const udm$E = {
+    singularName: 'campaign-member',
+    pluralName: 'campaign-members',
+    fieldsSchema: FIELDS_SCHEMA$E,
+    list: {
+        filterFields: [
+            'primaryEmail',
+            'fullName',
+            'firstName',
+            'lastName',
+            'campaignId',
+            'contactId',
+            'leadId',
+            'companyId',
+        ],
     },
-    getInputSchema: ({ collectionSpec, collectionHandler, credentialsSchema, method, parameters }) => {
-        var _a;
-        let fieldsSchema = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema;
-        if (method === null || method === void 0 ? void 0 : method.fields) {
-            fieldsSchema = pickFieldsFromSchema(fieldsSchema, method.fields);
-        }
-        if (method === null || method === void 0 ? void 0 : method.excludedFields) {
-            fieldsSchema = excludeFieldsFromSchema(fieldsSchema, method.excludedFields);
-        }
-        return {
-            type: 'object',
-            properties: nonEmptyObjectProperties({
-                id: {
-                    type: 'string',
-                    referenceCollection: { key: collectionHandler === null || collectionHandler === void 0 ? void 0 : collectionHandler.key, parameters },
-                },
-                fields: (_a = transformVariablesWith(fieldsSchema, (locator) => `fields.${locatorToField(locator)}`)) !== null && _a !== void 0 ? _a : {
-                    type: 'object',
-                },
-                credentials: credentialsSchema,
-            }),
-        };
+    match: {
+        fields: ['primaryEmail', 'fullName', 'firstName', 'lastName', 'campaignId', 'contactId', 'leadId', 'companyId'],
     },
-    getOutputSchema: ({}) => ({
-        type: 'object',
-        properties: {
-            id: { type: 'string' },
-        },
-    }),
-    supportedImplementationTypes: DataLocationMethodImplementationTypes,
 };
 
-const FIELDS_SCHEMA$G = {
+const FIELDS_SCHEMA$D = {
     type: 'object',
     properties: {
         id: { type: 'string', readOnly: true },
-        title: { type: 'string' },
-        description: { type: 'string' },
-        type: { type: 'string' },
-        durationSeconds: { type: 'number' },
-        location: { type: 'string' },
-        isRecurrent: { type: 'boolean' },
-        participants: {
-            type: 'array',
-            items: {
-                type: 'object',
-                properties: {
-                    userId: { type: 'string' },
-                    contactId: { type: 'string' },
-                },
-            },
+        name: {
+            type: 'string',
         },
-        status: { type: 'string' },
-        contactId: {
+        cost: {
+            type: 'number',
+        },
+        description: {
             type: 'string',
-            referenceUdm: 'contacts',
         },
-        companyId: {
+        source: {
             type: 'string',
-            referenceUdm: 'companies',
         },
-        dealId: {
+        stage: {
             type: 'string',
-            referenceUdm: 'deals',
         },
-        leadId: {
+        type: {
             type: 'string',
-            referenceUdm: 'leads',
         },
         ownerId: {
             type: 'string',
             referenceUdm: 'users',
         },
+        sentCount: {
+            type: 'number',
+            readOnly: true,
+        },
+        replyCount: {
+            type: 'number',
+            readOnly: true,
+        },
+        openCount: {
+            type: 'number',
+            readOnly: true,
+        },
+        clickCount: {
+            type: 'number',
+            readOnly: true,
+        },
         startTime: {
             type: 'string',
             format: 'date-time',
@@ -5038,10 +5200,6 @@ const FIELDS_SCHEMA$G = {
             type: 'string',
             format: 'date-time',
         },
-        dueTime: {
-            type: 'string',
-            format: 'date-time',
-        },
         createdTime: {
             type: 'string',
             format: 'date-time',
@@ -5062,477 +5220,167 @@ const FIELDS_SCHEMA$G = {
             referenceUdm: 'users',
             readOnly: true,
         },
+        lastActivityTime: {
+            type: 'string',
+            format: 'date-time',
+            readOnly: true,
+        },
     },
 };
-const FallbackFieldsMap = {
-    fromActivitiesToTasks: {
-        subject: {
-            $var: 'title',
-        },
-        content: {
-            $var: 'description',
-        },
+const MODIFIABLE_FIELDS$2 = ['name', 'description', 'ownerId', 'startTime', 'endTime', 'cost', 'source', 'stage', 'type'];
+const udm$D = {
+    singularName: 'campaign',
+    pluralName: 'campaigns',
+    fieldsSchema: FIELDS_SCHEMA$D,
+    categories: ['Marketing Automation', 'Sales', 'CRM', 'Ads'],
+    list: {
+        filterFields: ['name', 'source', 'stage', 'type', 'ownerId'],
     },
-    fromTasksToActivities: {
-        title: {
-            $var: 'subject',
-        },
-        description: {
-            $var: 'content',
-        },
+    find: {
+        queryFields: ['name', 'source', 'stage', 'type', 'ownerId'],
     },
-    fromActivitiesToNotes: {
-        content: {
-            $var: 'description',
-        },
+    match: {
+        fields: ['name', 'source', 'stage', 'type', 'ownerId'],
     },
-    fromNotesToActivities: {
-        description: {
-            $var: 'content',
-        },
-    },
-    fromActivitiesToEmails: {
-        subject: {
-            $var: 'title',
-        },
-        body: {
-            $var: 'description',
-        },
+    create: {
+        fields: MODIFIABLE_FIELDS$2,
     },
-    fromEmailsToActivities: {
-        title: {
-            $var: 'subject',
-        },
-        description: {
-            $var: 'body',
-        },
+    update: {
+        fields: MODIFIABLE_FIELDS$2,
     },
 };
-const udm$G = {
-    singularName: 'activity',
-    pluralName: 'activities',
-    fieldsSchema: FIELDS_SCHEMA$G,
-    list: {
-        filterFields: ['type', 'companyId', 'contactId', 'dealId', 'leadId', 'ownerId'],
+
+const AddressSchema = {
+    type: 'object',
+    properties: {
+        type: { type: 'string' },
+        full: { type: 'string' },
+        street: { type: 'string' },
+        city: { type: 'string' },
+        state: { type: 'string' },
+        country: { type: 'string' },
+        zip: { type: 'string' },
     },
-    match: {
-        fields: ['type', 'companyId', 'contactId', 'dealId', 'leadId', 'ownerId'],
+};
+const PhoneEmailSchema = {
+    type: 'object',
+    properties: {
+        value: { type: 'string' },
+        type: { type: 'string' },
     },
-    populateFields,
-    udmFallbacks: [
-        {
-            udm: 'tasks',
-            importFields: FallbackFieldsMap.fromTasksToActivities,
-            exportFields: FallbackFieldsMap.fromActivitiesToTasks,
-        },
-        {
-            udm: 'meetings',
-        },
-        {
-            udm: 'notes',
-            importFields: FallbackFieldsMap.fromNotesToActivities,
-            exportFields: FallbackFieldsMap.fromActivitiesToNotes,
-        },
-        {
-            udm: 'emails',
-            importFields: FallbackFieldsMap.fromEmailsToActivities,
-            exportFields: FallbackFieldsMap.fromActivitiesToEmails,
-        },
-    ],
 };
-function populateFields(fields) {
-    const result = JSON.parse(JSON.stringify(fields));
-    if (!result.dueTime) {
-        result.dueTime = result.endTime || result.startTime;
-    }
-    if (!result.startTime) {
-        result.startTime = result.dueTime || result.endTime;
-    }
-    if (!result.endTime) {
-        result.endTime = result.dueTime || result.startTime;
-    }
-    return result;
-}
 
-const FIELDS_SCHEMA$F = {
+const FIELDS_SCHEMA$C = {
     type: 'object',
     properties: {
         id: { type: 'string', readOnly: true },
-        number: { type: 'string' },
-        name: { type: 'string' },
-        memo: { type: 'string' },
-        status: { type: 'string' },
-        paymentMethod: { type: 'string' },
-        supplierId: { type: 'string', referenceUdm: 'suppliers' },
-        currency: { type: 'string' },
-        payments: {
-            type: 'array',
-            items: {
-                type: 'string',
-                referenceUdm: 'payments',
-            },
+        name: {
+            type: 'string',
         },
-        lineItems: {
+        websiteUrl: {
+            type: 'string',
+        },
+        phones: {
             type: 'array',
-            items: {
-                type: 'object',
-                properties: {
-                    id: { type: 'string' },
-                    itemName: { type: 'string' },
-                    description: { type: 'string' },
-                    code: { type: 'string' },
-                    type: { type: 'string' },
-                    companyId: { type: 'string', referenceUdm: 'companies' },
-                    ledgerAccountId: { type: 'string', referenceUdm: 'ledger-accounts' },
-                    quantity: { type: 'number' },
-                    unitPrice: { type: 'number' },
-                    unitOfMeasure: { type: 'string' },
-                    purchasePrice: { type: 'number' },
-                    salesPrice: { type: 'number' },
-                    taxable: { type: 'boolean' },
-                    taxAmount: { type: 'number' },
-                    totalAmount: { type: 'number' },
-                },
-            },
+            items: PhoneEmailSchema,
         },
-        totalAmount: { type: 'number' },
-        totalTax: { type: 'number' },
-        exchangeRate: { type: 'number' },
-        totalDiscount: { type: 'number' },
-        subTotal: { type: 'number' },
-        balance: { type: 'number' },
-        ledgerAccountId: { type: 'string', referenceUdm: 'ledger-accounts' },
-        issueDate: {
+        primaryPhone: {
             type: 'string',
-            format: 'date-time',
         },
-        dueDate: {
+        description: {
             type: 'string',
-            format: 'date-time',
         },
-        paidOnDate: {
+        currency: {
             type: 'string',
-            format: 'date-time',
         },
-        createdTime: { type: 'string', format: 'date-time', readOnly: true },
-        createdBy: { type: 'string', referenceUdm: 'users', readOnly: true },
-        updatedTime: { type: 'string', format: 'date-time', readOnly: true },
-        updatedBy: { type: 'string', referenceUdm: 'users', readOnly: true },
-    },
-};
-const udm$F = {
-    singularName: 'bill',
-    pluralName: 'bills',
-    fieldsSchema: FIELDS_SCHEMA$F,
-    list: {
-        filterFields: ['name', 'number', 'status', 'supplierId'],
-    },
-    match: {
-        fields: ['name', 'number', 'status', 'supplierId'],
-    },
-};
-
-const FIELDS_SCHEMA$E = {
-    type: 'object',
-    properties: {
-        id: { type: 'string', readOnly: true },
-        fullName: { type: 'string' },
-        firstName: { type: 'string' },
-        lastName: { type: 'string' },
-        primaryEmail: { type: 'string' },
-        campaignId: {
+        industry: {
             type: 'string',
-            referenceUdm: 'campaigns',
         },
-        contactId: {
+        ownerId: {
             type: 'string',
-            referenceUdm: 'contacts',
+            referenceUdm: 'users',
         },
-        leadId: {
-            type: 'string',
-            referenceUdm: 'leads',
+        primaryAddress: AddressSchema,
+        addresses: {
+            type: 'array',
+            items: AddressSchema,
         },
-        source: { type: 'string' },
-        status: { type: 'string' },
-        companyId: {
-            type: 'string',
-            referenceUdm: 'companies',
+        numberOfEmployees: {
+            type: 'number',
         },
-        jobTitle: { type: 'string' },
-        hasOptedOutOfEmail: { type: 'boolean' },
         createdTime: {
             type: 'string',
             format: 'date-time',
         },
         createdBy: {
             type: 'string',
-            readOnly: true,
             referenceUdm: 'users',
+            readOnly: true,
         },
         updatedTime: {
             type: 'string',
-            readOnly: true,
             format: 'date-time',
+            readOnly: true,
         },
         updatedBy: {
             type: 'string',
-            readOnly: true,
             referenceUdm: 'users',
+            readOnly: true,
+        },
+        lastActivityTime: {
+            type: 'string',
+            format: 'date-time',
+            readOnly: true,
         },
     },
 };
-const udm$E = {
-    singularName: 'campaign-member',
-    pluralName: 'campaign-members',
-    fieldsSchema: FIELDS_SCHEMA$E,
+const udm$C = {
+    singularName: 'company',
+    pluralName: 'companies',
+    fieldsSchema: FIELDS_SCHEMA$C,
     list: {
-        filterFields: [
-            'primaryEmail',
-            'fullName',
-            'firstName',
-            'lastName',
-            'campaignId',
-            'contactId',
-            'leadId',
-            'companyId',
-        ],
+        filterFields: ['ownerId', 'name', 'websiteUrl', 'industry'],
+    },
+    find: {
+        queryFields: ['ownerId', 'name', 'websiteUrl', 'industry'],
     },
     match: {
-        fields: ['primaryEmail', 'fullName', 'firstName', 'lastName', 'campaignId', 'contactId', 'leadId', 'companyId'],
+        fields: ['ownerId', 'name', 'websiteUrl', 'industry'],
+    },
+    fieldFallbacks: {
+        'primaryAddress.full': [
+            {
+                $concat: {
+                    values: [
+                        { $var: 'primaryAddress.street' },
+                        { $var: 'primaryAddress.city' },
+                        { $var: 'primaryAddress.state' },
+                        { $var: 'primaryAddress.zip' },
+                        { $var: 'primaryAddress.country' },
+                    ],
+                    delimiter: ', ',
+                },
+            },
+        ],
     },
 };
 
-const FIELDS_SCHEMA$D = {
+const FIELDS_SCHEMA$B = {
     type: 'object',
     properties: {
         id: { type: 'string', readOnly: true },
-        name: {
+        name: { type: 'string' },
+        description: { type: 'string' },
+        source: { type: 'string' },
+        type: { type: 'string' },
+        ownerId: {
             type: 'string',
+            referenceUdm: 'users',
         },
-        cost: {
-            type: 'number',
-        },
-        description: {
+        createdTime: {
             type: 'string',
-        },
-        source: {
-            type: 'string',
-        },
-        stage: {
-            type: 'string',
-        },
-        type: {
-            type: 'string',
-        },
-        ownerId: {
-            type: 'string',
-            referenceUdm: 'users',
-        },
-        sentCount: {
-            type: 'number',
-            readOnly: true,
-        },
-        replyCount: {
-            type: 'number',
-            readOnly: true,
-        },
-        openCount: {
-            type: 'number',
-            readOnly: true,
-        },
-        clickCount: {
-            type: 'number',
-            readOnly: true,
-        },
-        startTime: {
-            type: 'string',
-            format: 'date-time',
-        },
-        endTime: {
-            type: 'string',
-            format: 'date-time',
-        },
-        createdTime: {
-            type: 'string',
-            format: 'date-time',
-            readOnly: true,
-        },
-        createdBy: {
-            type: 'string',
-            referenceUdm: 'users',
-            readOnly: true,
-        },
-        updatedTime: {
-            type: 'string',
-            format: 'date-time',
-            readOnly: true,
-        },
-        updatedBy: {
-            type: 'string',
-            referenceUdm: 'users',
-            readOnly: true,
-        },
-        lastActivityTime: {
-            type: 'string',
-            format: 'date-time',
-            readOnly: true,
-        },
-    },
-};
-const MODIFIABLE_FIELDS$2 = ['name', 'description', 'ownerId', 'startTime', 'endTime', 'cost', 'source', 'stage', 'type'];
-const udm$D = {
-    singularName: 'campaign',
-    pluralName: 'campaigns',
-    fieldsSchema: FIELDS_SCHEMA$D,
-    categories: ['Marketing Automation', 'Sales', 'CRM', 'Ads'],
-    list: {
-        filterFields: ['name', 'source', 'stage', 'type', 'ownerId'],
-    },
-    find: {
-        queryFields: ['name', 'source', 'stage', 'type', 'ownerId'],
-    },
-    match: {
-        fields: ['name', 'source', 'stage', 'type', 'ownerId'],
-    },
-    create: {
-        fields: MODIFIABLE_FIELDS$2,
-    },
-    update: {
-        fields: MODIFIABLE_FIELDS$2,
-    },
-};
-
-const AddressSchema = {
-    type: 'object',
-    properties: {
-        type: { type: 'string' },
-        full: { type: 'string' },
-        street: { type: 'string' },
-        city: { type: 'string' },
-        state: { type: 'string' },
-        country: { type: 'string' },
-        zip: { type: 'string' },
-    },
-};
-const PhoneEmailSchema = {
-    type: 'object',
-    properties: {
-        value: { type: 'string' },
-        type: { type: 'string' },
-    },
-};
-
-const FIELDS_SCHEMA$C = {
-    type: 'object',
-    properties: {
-        id: { type: 'string', readOnly: true },
-        name: {
-            type: 'string',
-        },
-        websiteUrl: {
-            type: 'string',
-        },
-        phones: {
-            type: 'array',
-            items: PhoneEmailSchema,
-        },
-        primaryPhone: {
-            type: 'string',
-        },
-        description: {
-            type: 'string',
-        },
-        currency: {
-            type: 'string',
-        },
-        industry: {
-            type: 'string',
-        },
-        ownerId: {
-            type: 'string',
-            referenceUdm: 'users',
-        },
-        primaryAddress: AddressSchema,
-        addresses: {
-            type: 'array',
-            items: AddressSchema,
-        },
-        numberOfEmployees: {
-            type: 'number',
-        },
-        createdTime: {
-            type: 'string',
-            format: 'date-time',
-        },
-        createdBy: {
-            type: 'string',
-            referenceUdm: 'users',
-            readOnly: true,
-        },
-        updatedTime: {
-            type: 'string',
-            format: 'date-time',
-            readOnly: true,
-        },
-        updatedBy: {
-            type: 'string',
-            referenceUdm: 'users',
-            readOnly: true,
-        },
-        lastActivityTime: {
-            type: 'string',
-            format: 'date-time',
-            readOnly: true,
-        },
-    },
-};
-const udm$C = {
-    singularName: 'company',
-    pluralName: 'companies',
-    fieldsSchema: FIELDS_SCHEMA$C,
-    list: {
-        filterFields: ['ownerId', 'name', 'websiteUrl', 'industry'],
-    },
-    find: {
-        queryFields: ['ownerId', 'name', 'websiteUrl', 'industry'],
-    },
-    match: {
-        fields: ['ownerId', 'name', 'websiteUrl', 'industry'],
-    },
-    fieldFallbacks: {
-        'primaryAddress.full': [
-            {
-                $concat: {
-                    values: [
-                        { $var: 'primaryAddress.street' },
-                        { $var: 'primaryAddress.city' },
-                        { $var: 'primaryAddress.state' },
-                        { $var: 'primaryAddress.zip' },
-                        { $var: 'primaryAddress.country' },
-                    ],
-                    delimiter: ', ',
-                },
-            },
-        ],
-    },
-};
-
-const FIELDS_SCHEMA$B = {
-    type: 'object',
-    properties: {
-        id: { type: 'string', readOnly: true },
-        name: { type: 'string' },
-        description: { type: 'string' },
-        source: { type: 'string' },
-        type: { type: 'string' },
-        ownerId: {
-            type: 'string',
-            referenceUdm: 'users',
-        },
-        createdTime: {
-            type: 'string',
-            format: 'date-time',
-            readOnly: true,
+            format: 'date-time',
+            readOnly: true,
         },
         createdBy: {
             type: 'string',
@@ -7950,173 +7798,6 @@ const udm = {
     },
 };
 
-const structuredClone$1 = (structuredClonePolyfill === null || structuredClonePolyfill === void 0 ? void 0 : structuredClonePolyfill.default) || structuredClonePolyfill;
-function isNil(value) {
-    return value == null;
-}
-function omitBy(obj, check) {
-    obj = { ...obj };
-    Object.entries(obj).forEach(([key, value]) => check(value) && delete obj[key]);
-    return obj;
-}
-function isEmptyValue(value) {
-    if (isNil(value)) {
-        return true;
-    }
-    if (typeof value === 'symbol') {
-        return true;
-    }
-    if (typeof value === 'boolean') {
-        return false;
-    }
-    if (typeof value === 'number') {
-        return isNaN(value);
-    }
-    if (typeof value === 'string') {
-        return value.trim().length === 0;
-    }
-    const tag = value.toString();
-    if (tag === '[object Map]' || tag === '[object Set]') {
-        return !value.size;
-    }
-    return typeof value === 'object' && Object.keys(value).length === 0;
-}
-const simpleUniqueId = () => {
-    return Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)
-        .toString(36)
-        .padStart(11, '0')
-        .substring(0, 11);
-};
-
-function getDataLocationMethodPath(locationKey, methodKey) {
-    return `data/${locationKey}/${toKebabCase(methodKey)}`;
-}
-function dataLocationParametersMatch({ locationParameters, targetParameters, }) {
-    targetParameters = typeof targetParameters === 'object' && targetParameters ? targetParameters : {};
-    locationParameters = typeof locationParameters === 'object' && locationParameters ? locationParameters : {};
-    for (const [key, value] of Object.entries(targetParameters)) {
-        if (locationParameters[key] !== value) {
-            return false;
-        }
-    }
-    return true;
-}
-function parseDataLocationPath(path) {
-    if (!path) {
-        return undefined;
-    }
-    if (path.startsWith('/')) {
-        path = path.slice(1);
-    }
-    if (!path.startsWith('data/')) {
-        throw new Error(`Invalid data location path: ${path}. It should start with "data/"`);
-    }
-    path = path.slice(5);
-    const [key, query] = path.split('?');
-    const parameters = Object.fromEntries(new URLSearchParams(query).entries());
-    return { key, parameters };
-}
-function makeDataLocationPath(pointer) {
-    var _a;
-    const normalizedPointer = normalizePointer(pointer);
-    if (normalizedPointer === null || normalizedPointer === void 0 ? void 0 : normalizedPointer.key) {
-        let path = `/data/${normalizedPointer.key}`;
-        const parameters = omitBy((_a = normalizedPointer.parameters) !== null && _a !== void 0 ? _a : {}, isNil);
-        if (Object.keys(parameters).length > 0) {
-            path += `?${new URLSearchParams(parameters).toString()}`;
-        }
-        return path;
-    }
-    else {
-        return undefined;
-    }
-}
-function normalizePointer(pointer) {
-    if (typeof pointer === 'string' && pointer.startsWith('/data/')) {
-        return {
-            key: pointer.slice(6),
-        };
-    }
-    return pointer;
-}
-function makeDataLocationOperationPath(collectionPath, operation) {
-    const [path, query] = (collectionPath !== null && collectionPath !== void 0 ? collectionPath : '').split('?');
-    return urljoin(path, operation, query ? `?${query}` : '');
-}
-function isSameDataLocation(location1, location2) {
-    if (location1.key !== location2.key) {
-        return false;
-    }
-    const cleanParameters1 = location1.parameters && Object.keys(location1.parameters).length > 0 ? location1.parameters : undefined;
-    const cleanParameters2 = location2.parameters && Object.keys(location2.parameters).length > 0 ? location2.parameters : undefined;
-    if (!deepEqual(cleanParameters1, cleanParameters2)) {
-        return false;
-    }
-    return true;
-}
-function isDataLocationMethodSupported(location, methodKey) {
-    var _a;
-    const method = (_a = location === null || location === void 0 ? void 0 : location.methods) === null || _a === void 0 ? void 0 : _a[methodKey];
-    return method && method.implementationType !== ConnectorMethodImplementationType.notSupported;
-}
-function getDataCollectionCreateFields(spec) {
-    if (!spec)
-        return undefined;
-    if (!spec.fieldsSchema)
-        return undefined;
-    if (!spec.create)
-        return undefined;
-    let schema = excludeReadOnlyFieldsFromSchema(spec.fieldsSchema);
-    if (spec.create.fields) {
-        schema = pickFieldsFromSchema(schema, spec.create.fields);
-    }
-    if (spec.create.excludedFields) {
-        schema = excludeFieldsFromSchema(schema, spec.create.excludedFields);
-    }
-    return schema;
-}
-function getDataCollectionUpdateFields(spec) {
-    if (!spec)
-        return undefined;
-    if (!spec.fieldsSchema)
-        return undefined;
-    if (!spec.update)
-        return undefined;
-    let schema = excludeReadOnlyFieldsFromSchema(spec.fieldsSchema);
-    if (spec.update.fields) {
-        schema = pickFieldsFromSchema(schema, spec.update.fields);
-    }
-    if (spec.update.excludedFields) {
-        schema = excludeFieldsFromSchema(schema, spec.update.excludedFields);
-    }
-    return schema;
-}
-function getWritableFieldsSchema(spec) {
-    if (!spec)
-        return undefined;
-    if (!spec.fieldsSchema)
-        return undefined;
-    return mergeSchemas([getDataCollectionCreateFields(spec), getDataCollectionUpdateFields(spec)]);
-}
-function getReferenceCollectionPointerForSchema(schema) {
-    if ((schema === null || schema === void 0 ? void 0 : schema.referenceCollection) && schema.referenceCollection.key) {
-        return schema.referenceCollection;
-    }
-    else if (schema === null || schema === void 0 ? void 0 : schema.referenceCollectionPath) {
-        return parseDataLocationPath(schema.referenceCollectionPath);
-    }
-    else if (schema === null || schema === void 0 ? void 0 : schema.referenceCollectionUri) {
-        return parseDataLocationPath(schema.referenceCollectionUri);
-    }
-    else {
-        return undefined;
-    }
-}
-function getReferenceCollectionPathForSchema(schema) {
-    const pointer = getReferenceCollectionPointerForSchema(schema);
-    return makeDataLocationPath(pointer);
-}
-
 var UDM;
 (function (UDM) {
     UDM["ACTIVITIES"] = "activities";
@@ -8301,63 +7982,385 @@ function addUdmFallbackFields(fields, udm) {
     return result;
 }
 
-const DATA_RECORD_SCHEMA = {
-    type: 'object',
-    properties: {
-        id: {
-            type: 'string',
-        },
-        name: {
-            type: 'string',
-        },
-        uri: {
-            type: 'string',
-            format: 'url',
-        },
-        createdTime: {
-            type: 'string',
-            format: 'datetime',
-        },
-        updatedTime: {
-            type: 'string',
-            format: 'datetime',
-        },
-        deletedTime: {
-            type: 'string',
-            format: 'datetime',
-        },
-        createdById: {
-            type: 'string',
-        },
-        updatedById: {
-            type: 'string',
-        },
+const DATA_RECORD_SCHEMA = {
+    type: 'object',
+    properties: {
+        id: {
+            type: 'string',
+        },
+        name: {
+            type: 'string',
+        },
+        uri: {
+            type: 'string',
+            format: 'url',
+        },
+        createdTime: {
+            type: 'string',
+            format: 'datetime',
+        },
+        updatedTime: {
+            type: 'string',
+            format: 'datetime',
+        },
+        deletedTime: {
+            type: 'string',
+            format: 'datetime',
+        },
+        createdById: {
+            type: 'string',
+        },
+        updatedById: {
+            type: 'string',
+        },
+    },
+};
+function makeDataRecordSchema({ fieldsSchema, udm, rawFieldsSchema, }) {
+    var _a, _b, _c;
+    const schema = structuredClone$1(DATA_RECORD_SCHEMA);
+    schema.properties = {
+        ...((_a = schema.properties) !== null && _a !== void 0 ? _a : {}),
+        fields: fieldsSchema !== null && fieldsSchema !== void 0 ? fieldsSchema : { type: 'object' },
+    };
+    if (udm) {
+        const unifiedModel = UNIFIED_DATA_MODELS[udm];
+        if (unifiedModel === null || unifiedModel === void 0 ? void 0 : unifiedModel.fieldsSchema) {
+            schema.properties = {
+                ...((_b = schema.properties) !== null && _b !== void 0 ? _b : {}),
+                unifiedFields: unifiedModel.fieldsSchema,
+            };
+        }
+    }
+    if (rawFieldsSchema) {
+        schema.properties = {
+            ...((_c = schema.properties) !== null && _c !== void 0 ? _c : {}),
+            rawFields: rawFieldsSchema,
+        };
+    }
+    return schema;
+}
+
+const DataLocationMethodImplementationTypes = [
+    ConnectorMethodImplementationType.operationMapping,
+    ConnectorMethodImplementationType.restApiMapping,
+    ConnectorMethodImplementationType.graphqlApiMapping,
+    ConnectorMethodImplementationType.javascript,
+    ConnectorMethodImplementationType.notSupported,
+];
+
+const DataCollectionMethodCreate = {
+    name: 'Create',
+    description: 'Create a new data record in the collection',
+    getConfigSchema: ({ collectionSpec }) => {
+        var _a, _b;
+        const fields = Object.keys((_b = (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : {}).map(locatorToField);
+        return {
+            type: 'object',
+            properties: {
+                fields: {
+                    type: 'array',
+                    items: { type: 'string', enum: fields },
+                },
+                excludedFields: {
+                    type: 'array',
+                    items: { type: 'string', enum: fields },
+                },
+            },
+        };
+    },
+    getInputSchema: ({ collectionSpec, method, credentialsSchema }) => {
+        var _a;
+        let fieldsSchema = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema;
+        if (method === null || method === void 0 ? void 0 : method.fields) {
+            fieldsSchema = pickFieldsFromSchema(fieldsSchema, method.fields);
+        }
+        if (method === null || method === void 0 ? void 0 : method.excludedFields) {
+            fieldsSchema = excludeFieldsFromSchema(fieldsSchema, method.excludedFields);
+        }
+        return {
+            type: 'object',
+            properties: nonEmptyObjectProperties({
+                fields: (_a = transformVariablesWith(fieldsSchema, (locator) => `fields.${locatorToField(locator)}`)) !== null && _a !== void 0 ? _a : {
+                    type: 'object',
+                },
+                credentials: credentialsSchema,
+            }),
+        };
+    },
+    getOutputSchema: ({}) => ({
+        type: 'object',
+        properties: {
+            id: { type: 'string' },
+        },
+    }),
+    supportedImplementationTypes: DataLocationMethodImplementationTypes,
+};
+
+const DataCollectionMethodDelete = {
+    name: 'Delete',
+    description: 'Delete a data record from the collection by id',
+    getInputSchema: ({ collectionHandler, parameters, credentialsSchema }) => {
+        return {
+            type: 'object',
+            properties: nonEmptyObjectProperties({
+                id: {
+                    type: 'string',
+                    referenceCollection: { key: collectionHandler === null || collectionHandler === void 0 ? void 0 : collectionHandler.key, parameters },
+                },
+                credentials: credentialsSchema,
+            }),
+        };
+    },
+    getOutputSchema: () => null,
+    supportedImplementationTypes: DataLocationMethodImplementationTypes,
+};
+
+const DataCollectionMethodFind = {
+    isDeprecated: true,
+    name: 'Find',
+    description: 'Find a list of data records in the collection',
+    getConfigSchema: ({ collectionSpec }) => {
+        var _a, _b;
+        const fields = Object.keys((_b = (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : {}).map(locatorToField);
+        return {
+            type: 'object',
+            properties: {
+                queryFields: {
+                    type: 'array',
+                    items: { type: 'string', enum: fields },
+                },
+            },
+        };
+    },
+    getInputSchema: ({ collectionSpec, method, credentialsSchema }) => {
+        const queryFieldsSchema = pickFieldsFromSchema(collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema, method === null || method === void 0 ? void 0 : method.queryFields);
+        const schema = {
+            type: 'object',
+            properties: nonEmptyObjectProperties({
+                cursor: { type: 'string' },
+                credentials: credentialsSchema,
+            }),
+        };
+        if (queryFieldsSchema === null || queryFieldsSchema === void 0 ? void 0 : queryFieldsSchema.properties) {
+            schema.properties = {
+                ...schema.properties,
+                query: transformVariablesWith(queryFieldsSchema, (locator) => `query.${locatorToField(locator)}`),
+            };
+        }
+        return schema;
+    },
+    getOutputSchema: ({ collectionSpec }) => {
+        var _a;
+        return ({
+            type: 'object',
+            properties: {
+                records: {
+                    type: 'array',
+                    items: (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) !== null && _a !== void 0 ? _a : { type: 'object' },
+                },
+                cursor: {
+                    type: 'string',
+                },
+            },
+        });
+    },
+    supportedImplementationTypes: DataLocationMethodImplementationTypes,
+};
+
+const DataCollectionMethodFindById = {
+    name: 'Find by ID',
+    description: 'Find a single data record in the collection by its id',
+    getInputSchema: ({ collectionHandler, parameters, credentialsSchema }) => ({
+        type: 'object',
+        properties: nonEmptyObjectProperties({
+            id: {
+                type: 'string',
+                referenceCollection: { key: collectionHandler === null || collectionHandler === void 0 ? void 0 : collectionHandler.key, parameters },
+            },
+            credentials: credentialsSchema,
+        }),
+    }),
+    getOutputSchema: ({ collectionSpec }) => {
+        var _a;
+        return ({
+            type: 'object',
+            properties: {
+                record: (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) !== null && _a !== void 0 ? _a : { type: 'object' },
+            },
+        });
+    },
+    supportedImplementationTypes: DataLocationMethodImplementationTypes,
+};
+
+const DataCollectionMethodList = {
+    name: 'List',
+    description: 'Return all data records from the collection',
+    getConfigSchema: ({ collectionSpec }) => {
+        var _a, _b;
+        const fields = Object.keys((_b = (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : {}).map(locatorToField);
+        return {
+            type: 'object',
+            properties: {
+                filterFields: {
+                    type: 'array',
+                    items: { type: 'string', enum: fields },
+                },
+            },
+        };
+    },
+    getInputSchema: ({ method, collectionSpec, credentialsSchema }) => {
+        const fieldsSchema = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema;
+        let filterSchema;
+        if (method === null || method === void 0 ? void 0 : method.filterFields) {
+            filterSchema = pickFieldsFromSchema(fieldsSchema, method.filterFields);
+        }
+        return {
+            type: 'object',
+            properties: nonEmptyObjectProperties({
+                filter: filterSchema,
+                cursor: {
+                    type: 'string',
+                    description: 'Cursor returned in response to the previous "list" request',
+                },
+                credentials: credentialsSchema,
+            }),
+        };
+    },
+    getOutputSchema: ({ collectionSpec }) => {
+        var _a;
+        return ({
+            type: 'object',
+            properties: {
+                records: {
+                    type: 'array',
+                    items: (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) !== null && _a !== void 0 ? _a : { type: 'object' },
+                },
+                cursor: {
+                    type: 'string',
+                    description: 'Cursor to request the next page of results',
+                },
+            },
+        });
+    },
+    supportedImplementationTypes: DataLocationMethodImplementationTypes,
+};
+
+const DataCollectionMethodMatch = {
+    name: 'Match',
+    description: 'Find a single matching record in a data collection by a set of fields',
+    getConfigSchema: ({ collectionSpec }) => {
+        var _a, _b;
+        const fields = Object.keys((_b = (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : {}).map(locatorToField);
+        return {
+            type: 'object',
+            properties: {
+                fields: {
+                    type: 'array',
+                    items: { type: 'string', enum: fields },
+                },
+            },
+        };
+    },
+    getInputSchema: ({ collectionSpec, method, credentialsSchema }) => {
+        const fieldsSchema = pickFieldsFromSchema(collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema, method === null || method === void 0 ? void 0 : method.fields);
+        return {
+            type: 'object',
+            properties: nonEmptyObjectProperties({
+                query: transformVariablesWith(fieldsSchema !== null && fieldsSchema !== void 0 ? fieldsSchema : {}, (locator) => `query.${locatorToField(locator)}`),
+                credentials: credentialsSchema,
+            }),
+        };
+    },
+    getOutputSchema: ({ collectionSpec }) => {
+        var _a;
+        return ({
+            type: 'object',
+            properties: {
+                record: (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) !== null && _a !== void 0 ? _a : { type: 'object' },
+            },
+        });
+    },
+    supportedImplementationTypes: DataLocationMethodImplementationTypes,
+};
+
+const DataCollectionMethodSearch = {
+    name: 'Search',
+    description: 'Find data records in a collection by a string query',
+    getInputSchema: ({ credentialsSchema }) => ({
+        type: 'object',
+        properties: nonEmptyObjectProperties({
+            query: { type: 'string' },
+            cursor: { type: 'string' },
+            credentials: credentialsSchema,
+        }),
+    }),
+    getOutputSchema: ({ collectionSpec }) => {
+        var _a;
+        return ({
+            type: 'object',
+            properties: {
+                records: {
+                    type: 'array',
+                    items: (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) !== null && _a !== void 0 ? _a : { type: 'object' },
+                },
+                cursor: { type: 'string' },
+            },
+        });
     },
+    supportedImplementationTypes: DataLocationMethodImplementationTypes,
 };
-function makeDataRecordSchema({ fieldsSchema, udm, rawFieldsSchema, }) {
-    var _a, _b, _c;
-    const schema = structuredClone$1(DATA_RECORD_SCHEMA);
-    schema.properties = {
-        ...((_a = schema.properties) !== null && _a !== void 0 ? _a : {}),
-        fields: fieldsSchema !== null && fieldsSchema !== void 0 ? fieldsSchema : { type: 'object' },
-    };
-    if (udm) {
-        const unifiedModel = UNIFIED_DATA_MODELS[udm];
-        if (unifiedModel === null || unifiedModel === void 0 ? void 0 : unifiedModel.fieldsSchema) {
-            schema.properties = {
-                ...((_b = schema.properties) !== null && _b !== void 0 ? _b : {}),
-                unifiedFields: unifiedModel.fieldsSchema,
-            };
+
+const DataCollectionMethodUpdate = {
+    name: 'Update',
+    description: 'Update one data record in the collection by its id',
+    getConfigSchema: ({ collectionSpec }) => {
+        var _a, _b;
+        const fields = Object.keys((_b = (_a = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema) === null || _a === void 0 ? void 0 : _a.properties) !== null && _b !== void 0 ? _b : {}).map(locatorToField);
+        return {
+            type: 'object',
+            properties: {
+                fields: {
+                    type: 'array',
+                    items: { type: 'string', enum: fields },
+                },
+                excludedFields: {
+                    type: 'array',
+                    items: { type: 'string', enum: fields },
+                },
+            },
+        };
+    },
+    getInputSchema: ({ collectionSpec, collectionHandler, credentialsSchema, method, parameters }) => {
+        var _a;
+        let fieldsSchema = collectionSpec === null || collectionSpec === void 0 ? void 0 : collectionSpec.fieldsSchema;
+        if (method === null || method === void 0 ? void 0 : method.fields) {
+            fieldsSchema = pickFieldsFromSchema(fieldsSchema, method.fields);
         }
-    }
-    if (rawFieldsSchema) {
-        schema.properties = {
-            ...((_c = schema.properties) !== null && _c !== void 0 ? _c : {}),
-            rawFields: rawFieldsSchema,
+        if (method === null || method === void 0 ? void 0 : method.excludedFields) {
+            fieldsSchema = excludeFieldsFromSchema(fieldsSchema, method.excludedFields);
+        }
+        return {
+            type: 'object',
+            properties: nonEmptyObjectProperties({
+                id: {
+                    type: 'string',
+                    referenceCollection: { key: collectionHandler === null || collectionHandler === void 0 ? void 0 : collectionHandler.key, parameters },
+                },
+                fields: (_a = transformVariablesWith(fieldsSchema, (locator) => `fields.${locatorToField(locator)}`)) !== null && _a !== void 0 ? _a : {
+                    type: 'object',
+                },
+                credentials: credentialsSchema,
+            }),
         };
-    }
-    return schema;
-}
+    },
+    getOutputSchema: ({}) => ({
+        type: 'object',
+        properties: {
+            id: { type: 'string' },
+        },
+    }),
+    supportedImplementationTypes: DataLocationMethodImplementationTypes,
+};
 
 const GetEventConfig = {
     fileKey: 'connector-event-get-event-config',
@@ -9106,6 +9109,7 @@ const GeneratedConnectorOption = z.object({
     description: z.string().optional(),
     inputSchema: DataSchema.optional(),
     connectorParametersSchema: DataSchema.optional(),
+    oAuthCallbackUri: z.string().optional(),
 });
 const ConnectorOptions = z.record(z.string(), ConnectorOption);
 const WritableConnectorVersionData = ConnectorAuthWithFunctions.extend({
@@ -10258,6 +10262,9 @@ const FindActionRunLogsQuery = PaginationQuery.extend({
         .meta({
         filterTitle: 'Status',
     }),
+    externalAppId: z.string().optional().meta({
+        hidden: true,
+    }),
     from: z
         .string()
         .optional()
@@ -10298,6 +10305,13 @@ const FindConnectionsQuery = PaginationQuery.merge(SearchQuery)
         .meta({
         filterTitle: 'Connector',
     }),
+    externalAppId: z
+        .string()
+        .optional()
+        .meta({
+        filterTitle: 'External App',
+        referenceElementType: WorkspaceElementType.App,
+    }),
     disconnected: zodBooleanCoercion()
         .optional()
         .meta({
@@ -10318,10 +10332,6 @@ const FindConnectionsQuery = PaginationQuery.merge(SearchQuery)
         .string()
         .optional()
         .meta({ hidden: true }),
-    externalAppId: z.string().optional().meta({
-        filterTitle: 'External App',
-        referenceElementType: WorkspaceElementType.App,
-    }),
     integrationKey: z
         .string()
         .optional()
@@ -10444,6 +10454,13 @@ const DataSourceInstanceApiResponse = DataSourceApiResponse;
 const FindDataSourcesQuery = FindIntegrationLevelMembraneInterfaceQuery.omit({ parentId: true }).extend({
     dataSourceId: z.string().optional(),
     universalDataSourceId: z.string().optional(),
+    externalAppId: z
+        .string()
+        .optional()
+        .meta({
+        filterTitle: 'External App',
+        referenceElementType: WorkspaceElementType.App,
+    }),
 });
 const FindDataSourceInstancesQuery = FindDataSourcesQuery;
 const CreateDataSourceRequest = DataSourceEditableProperties;
@@ -10527,6 +10544,13 @@ const FlowInstanceApiResponse = FlowApiResponse;
 const FindFlowsQuery = FindIntegrationLevelMembraneInterfaceQuery.omit({ parentId: true }).extend({
     flowId: z.string().optional(),
     universalFlowId: z.string().optional(),
+    externalAppId: z
+        .string()
+        .optional()
+        .meta({
+        filterTitle: 'External App',
+        referenceElementType: WorkspaceElementType.App,
+    }),
 });
 const CreateFlowRequest = FlowEditableProperties;
 const UpdateFlowRequest = CreateFlowRequest.extend({}).partial();
@@ -10604,6 +10628,9 @@ const FindFlowRunsQuery = PaginationQuery.extend({
         filterTitle: 'Connection',
         referenceElementType: WorkspaceElementType.Connection,
     }),
+    externalAppId: z.string().optional().meta({
+        hidden: true,
+    }),
     from: z
         .string()
         .optional()
@@ -10766,6 +10793,13 @@ const FieldMappingInstanceApiResponse = FieldMappingApiResponse;
 const FindFieldMappingsQuery = FindIntegrationLevelMembraneInterfaceQuery.omit({ parentId: true }).extend({
     fieldMappingId: z.string().optional(),
     universalFieldMappingId: z.string().optional(),
+    externalAppId: z
+        .string()
+        .optional()
+        .meta({
+        filterTitle: 'External App',
+        referenceElementType: WorkspaceElementType.App,
+    }),
 });
 const FindFieldMappingInstancesQuery = FindFieldMappingsQuery;
 const CreateFieldMappingRequest = FieldMappingEditableProperties;
@@ -11037,6 +11071,9 @@ const ListExternalEventLogRecordsQuery = PaginationQuery.extend({
         .meta({
         filterTitle: 'Status',
     }),
+    externalAppId: z.string().optional().meta({
+        hidden: true,
+    }),
     from: z
         .string()
         .optional()
@@ -11126,6 +11163,9 @@ const FindExternalEventPullsQuery = PaginationQuery.extend({
         .meta({
         filterTitle: 'Status',
     }),
+    externalAppId: z.string().optional().meta({
+        hidden: true,
+    }),
     from: z
         .string()
         .optional()
@@ -11173,6 +11213,9 @@ const ListExternalEventSubscriptionsQuery = PaginationQuery.merge(IncludeArchive
         filterTitle: 'Integration',
         referenceElementType: WorkspaceElementType.Integration,
     }),
+    externalAppId: z.string().optional().meta({
+        hidden: true,
+    }),
 });
 const ExternalEventSubscriptionApiResponse = BaseExternalEventSubscription.extend({
     user: BaseCustomer.optional(),
@@ -11255,6 +11298,9 @@ const ListExternalApiLogsQuery = PaginationQuery.extend({
         filterTitle: 'Status',
         isFlag: true,
     }),
+    externalAppId: z.string().optional().meta({
+        hidden: true,
+    }),
     from: z
         .string()
         .optional()
@@ -11279,6 +11325,7 @@ const ExternalApiLogApiResponse = z.object({
     customerId: z.string(),
     integrationId: z.string(),
     connectionId: z.string(),
+    externalAppId: z.string().optional(),
     statusCode: z.number(),
     isSuccess: z.boolean(),
     s3Uri: z.string(),
@@ -11318,6 +11365,9 @@ const ListIncomingWebhooksQuery = PaginationQuery.extend({
         .meta({
         filterTitle: 'Status',
     }),
+    externalAppId: z.string().optional().meta({
+        hidden: true,
+    }),
     from: z
         .string()
         .optional()
@@ -11340,6 +11390,7 @@ const IncomingWebhookApiResponse = z.object({
     customerId: z.string(),
     integrationId: z.string(),
     connectionId: z.string(),
+    externalAppId: z.string().optional(),
     subscriptionId: z.string(),
     userId: z.string(),
     uuid: z.string(),
@@ -11353,12 +11404,14 @@ const IncomingWebhookApiResponse = z.object({
 
 const CreateConnectedProductRequest = z.object({
     name: z.string(),
+    key: z.string().optional(),
     type: ConnectedProductType,
     audience: ConnectedProductAudience.optional(),
     parameters: AiAgentParameters.optional(),
 });
 const UpdateConnectedProductRequest = z.object({
     name: z.string().optional(),
+    key: z.string().optional(),
     type: ConnectedProductType.optional(),
     audience: ConnectedProductAudience.optional(),
     parameters: AiAgentParameters.optional(),
@@ -11367,7 +11420,6 @@ const FindConnectedProductsQuery = z
     .object({
     type: ConnectedProductType.optional(),
     audience: ConnectedProductAudience.optional(),
-    key: z.string().optional(),
 })
     .merge(PaginationQuery)
     .merge(SearchQuery)
@@ -11693,6 +11745,26 @@ const WorkspaceElementSpecs = {
         apiPath: 'customers',
         name: 'Customer',
         namePlural: 'Customers',
+        relatedIntegrationLayerElements: [
+            WorkspaceElementType.Connection,
+            WorkspaceElementType.Action,
+            WorkspaceElementType.Flow,
+            WorkspaceElementType.ExternalEventSubscription,
+            WorkspaceElementType.AppEventSubscription,
+            WorkspaceElementType.DataSource,
+            WorkspaceElementType.FieldMapping,
+            WorkspaceElementType.AppDataSchemaInstance,
+            WorkspaceElementType.DataLinkTableInstance,
+        ],
+        relatedActivityLogElements: [
+            WorkspaceElementType.FlowRun,
+            WorkspaceElementType.ActionRunLogRecord,
+            WorkspaceElementType.ExternalApiLogRecord,
+            WorkspaceElementType.IncomingWebhookLogRecord,
+            WorkspaceElementType.ExternalEventLogRecord,
+            WorkspaceElementType.ExternalEventPull,
+            WorkspaceElementType.AppEventLogRecord,
+        ],
     },
     [WorkspaceElementType.App]: {
         type: WorkspaceElementType.App,
@@ -11701,6 +11773,21 @@ const WorkspaceElementSpecs = {
         namePlural: 'Apps',
         hasKey: true,
         hasPublicLayer: true,
+        relatedIntegrationLayerElements: [
+            WorkspaceElementType.Connection,
+            WorkspaceElementType.Action,
+            WorkspaceElementType.Flow,
+            WorkspaceElementType.DataSource,
+            WorkspaceElementType.FieldMapping,
+        ],
+        relatedActivityLogElements: [
+            WorkspaceElementType.FlowRun,
+            WorkspaceElementType.ActionRunLogRecord,
+            WorkspaceElementType.ExternalApiLogRecord,
+            WorkspaceElementType.IncomingWebhookLogRecord,
+            WorkspaceElementType.ExternalEventLogRecord,
+            WorkspaceElementType.ExternalEventPull,
+        ],
     },
     [WorkspaceElementType.Integration]: {
         type: WorkspaceElementType.Integration,
@@ -11710,6 +11797,27 @@ const WorkspaceElementSpecs = {
         editablePropertiesSchema: IntegrationEditableProperties,
         exportPropertiesSchema: IntegrationExportProperties,
         hasKey: true,
+        relatedIntegrationLayerElements: [
+            WorkspaceElementType.Connection,
+            WorkspaceElementType.Package,
+            WorkspaceElementType.Action,
+            WorkspaceElementType.Flow,
+            WorkspaceElementType.ExternalEventSubscription,
+            WorkspaceElementType.AppEventSubscription,
+            WorkspaceElementType.DataSource,
+            WorkspaceElementType.FieldMapping,
+            WorkspaceElementType.AppDataSchemaInstance,
+            WorkspaceElementType.DataLinkTableInstance,
+        ],
+        relatedActivityLogElements: [
+            WorkspaceElementType.FlowRun,
+            WorkspaceElementType.ActionRunLogRecord,
+            WorkspaceElementType.ExternalApiLogRecord,
+            WorkspaceElementType.IncomingWebhookLogRecord,
+            WorkspaceElementType.ExternalEventLogRecord,
+            WorkspaceElementType.ExternalEventPull,
+            WorkspaceElementType.AppEventLogRecord,
+        ],
     },
     [WorkspaceElementType.Connector]: {
         type: WorkspaceElementType.Connector,
@@ -11728,6 +11836,26 @@ const WorkspaceElementSpecs = {
         exportPropertiesSchema: ConnectionExportProperties,
         hasKey: false,
         hasUuid: false,
+        statsKey: 'connections',
+        relatedIntegrationLayerElements: [
+            WorkspaceElementType.Action,
+            WorkspaceElementType.Flow,
+            WorkspaceElementType.ExternalEventSubscription,
+            WorkspaceElementType.AppEventSubscription,
+            WorkspaceElementType.DataSource,
+            WorkspaceElementType.FieldMapping,
+            WorkspaceElementType.AppDataSchemaInstance,
+            WorkspaceElementType.DataLinkTableInstance,
+        ],
+        relatedActivityLogElements: [
+            WorkspaceElementType.FlowRun,
+            WorkspaceElementType.ActionRunLogRecord,
+            WorkspaceElementType.ExternalApiLogRecord,
+            WorkspaceElementType.IncomingWebhookLogRecord,
+            WorkspaceElementType.ExternalEventLogRecord,
+            WorkspaceElementType.ExternalEventPull,
+            WorkspaceElementType.AppEventLogRecord,
+        ],
     },
     [WorkspaceElementType.Package]: {
         type: WorkspaceElementType.Package,
@@ -11744,6 +11872,7 @@ const WorkspaceElementSpecs = {
         hasParentChildRelationship: true,
         hasPublicLayer: true,
         isProOnly: true,
+        statsKey: 'packages',
     },
     [WorkspaceElementType.ActionInstance]: {
         type: WorkspaceElementType.ActionInstance,
@@ -11770,12 +11899,14 @@ const WorkspaceElementSpecs = {
         hasParentChildRelationship: true,
         hasKey: true,
         hasPublicLayer: true,
+        statsKey: 'actions',
     },
     [WorkspaceElementType.ActionRunLogRecord]: {
         type: WorkspaceElementType.ActionRunLogRecord,
         apiPath: 'action-run-logs',
         name: 'Action Run Log Record',
         namePlural: 'Action Run Log Records',
+        statsKey: 'actionRunLogs',
     },
     [WorkspaceElementType.Flow]: {
         type: WorkspaceElementType.Flow,
@@ -11793,6 +11924,7 @@ const WorkspaceElementSpecs = {
         hasParentChildRelationship: true,
         hasKey: true,
         isProOnly: true,
+        statsKey: 'flows',
     },
     [WorkspaceElementType.FlowInstance]: {
         type: WorkspaceElementType.FlowInstance,
@@ -11813,6 +11945,7 @@ const WorkspaceElementSpecs = {
         name: 'Flow run',
         namePlural: 'Flow runs',
         isProOnly: true,
+        statsKey: 'flowRuns',
     },
     [WorkspaceElementType.FieldMapping]: {
         type: WorkspaceElementType.FieldMapping,
@@ -11830,6 +11963,7 @@ const WorkspaceElementSpecs = {
         hasParentChildRelationship: true,
         hasKey: true,
         isProOnly: true,
+        statsKey: 'fieldMappings',
     },
     [WorkspaceElementType.FieldMappingInstance]: {
         type: WorkspaceElementType.FieldMappingInstance,
@@ -11859,6 +11993,7 @@ const WorkspaceElementSpecs = {
         hasParentChildRelationship: true,
         hasKey: true,
         isProOnly: true,
+        statsKey: 'dataSources',
     },
     [WorkspaceElementType.DataSourceInstance]: {
         type: WorkspaceElementType.DataSourceInstance,
@@ -11893,6 +12028,7 @@ const WorkspaceElementSpecs = {
         parentFieldKey: 'dataLinkTableId',
         isMembraneInterface: true,
         isProOnly: true,
+        statsKey: 'dataLinkTableInstances',
     },
     [WorkspaceElementType.AppEventType]: {
         type: WorkspaceElementType.AppEventType,
@@ -11913,6 +12049,7 @@ const WorkspaceElementSpecs = {
         namePlural: 'App Event Subscriptions',
         isMembraneInterface: true,
         isProOnly: true,
+        statsKey: 'appEventSubscriptions',
     },
     [WorkspaceElementType.AppEventLogRecord]: {
         type: WorkspaceElementType.AppEventLogRecord,
@@ -11920,6 +12057,7 @@ const WorkspaceElementSpecs = {
         name: 'App Event Log Record',
         namePlural: 'App Event Log Records',
         isProOnly: true,
+        statsKey: 'appEvents',
     },
     [WorkspaceElementType.AppDataSchema]: {
         type: WorkspaceElementType.AppDataSchema,
@@ -11941,6 +12079,7 @@ const WorkspaceElementSpecs = {
         parentFieldKey: 'appDataSchemaId',
         isMembraneInterface: true,
         isProOnly: true,
+        statsKey: 'appDataSchemaInstances',
     },
     [WorkspaceElementType.ExternalEventSubscription]: {
         type: WorkspaceElementType.ExternalEventSubscription,
@@ -11949,6 +12088,7 @@ const WorkspaceElementSpecs = {
         namePlural: 'External Event Subscriptions',
         isMembraneInterface: true,
         isProOnly: true,
+        statsKey: 'externalEventSubscriptions',
     },
     [WorkspaceElementType.ExternalEventLogRecord]: {
         type: WorkspaceElementType.ExternalEventLogRecord,
@@ -11956,6 +12096,7 @@ const WorkspaceElementSpecs = {
         name: 'External Event Log Record',
         namePlural: 'External Event Log Records',
         isProOnly: true,
+        statsKey: 'externalEvents',
     },
     [WorkspaceElementType.ExternalEventPull]: {
         type: WorkspaceElementType.ExternalEventPull,
@@ -11963,6 +12104,21 @@ const WorkspaceElementSpecs = {
         name: 'External Event Pull',
         namePlural: 'External Event Pulls',
         isProOnly: true,
+        statsKey: 'externalEventPulls',
+    },
+    [WorkspaceElementType.ExternalApiLogRecord]: {
+        type: WorkspaceElementType.ExternalApiLogRecord,
+        apiPath: 'external-api-logs',
+        name: 'External API Log Record',
+        namePlural: 'External API Log Records',
+        statsKey: 'externalApiLogs',
+    },
+    [WorkspaceElementType.IncomingWebhookLogRecord]: {
+        type: WorkspaceElementType.IncomingWebhookLogRecord,
+        apiPath: 'incoming-webhooks',
+        name: 'Incoming Webhook Log Record',
+        namePlural: 'Incoming Webhook Log Records',
+        statsKey: 'externalWebhookLogs',
     },
     [WorkspaceElementType.Screen]: {
         type: WorkspaceElementType.Screen,
@@ -12366,20 +12522,21 @@ const StatsFilterQuery = z.object({
     tenantId: z.string().optional(),
     integrationId: z.string().optional(),
     connectionId: z.string().optional(),
+    externalAppId: z.string().optional(),
 });
 const ActivityStatsQuery = StatsFilterQuery.extend({
     startDatetime: z.string().datetime({ offset: true }),
+    elementType: z.enum(WorkspaceElementType).optional(),
+});
+const IntegrationLayerStatsQuery = StatsFilterQuery.extend({
+    elementType: z.enum(WorkspaceElementType).optional(),
 });
-const IntegrationLayerStatsQuery = StatsFilterQuery;
 const ActionRunsStatsQuery = z.object({
-    actionId: z.string().optional(),
-    connectionActionId: z.string().optional(),
+    actionId: z.string(),
     startDatetime: z.string().datetime({ offset: true }),
 });
 const FlowRunsStatsQuery = z.object({
-    integrationFlowId: z.string().optional(),
-    connectionFlowId: z.string().optional(),
-    universalFlowId: z.string().optional(),
+    flowId: z.string(),
     startDatetime: z.string().datetime({ offset: true }),
 });
 const WORKSPACE_ELEMENTS_STATS_COLLECTIONS = [
@@ -12940,6 +13097,7 @@ const WORKSPACE_SIZE_LIMITS = [
 const EDITABLE_LIMITS = [
     'parallelApiRequestsPerCustomer',
     'parallelBackgroundJobsPerCustomer',
+    'parallelCustomCodeRunsPerCustomer',
     'apiRequestsPerCustomerPerSecond',
     'apiRequestsPerCustomerPerHour',
     'externalEventsPerCustomerPerDay',
@@ -15313,6 +15471,7 @@ const AgentSession = z.object({
     hasWorker: z.boolean(),
     isExternal: z.boolean().optional(),
     agentName: z.enum(AgentName).optional(),
+    output: z.record(z.string(), z.unknown()).optional(),
     createdAt: z.iso.datetime(),
     updatedAt: z.iso.datetime(),
 });
@@ -15340,6 +15499,7 @@ const PatchAgentSessionSchema = z.object({
     cost: z.number().optional(),
     error: ErrorDataSchema.optional(),
     opencodeSessionUuid: z.string().optional(),
+    output: z.record(z.string(), z.unknown()).optional(),
     status: z.enum(AgentSessionStatus).optional(),
 });
 
@@ -15472,25 +15632,6 @@ const CreateClusterRequest = z.object({
 });
 const ListClustersQuery = PaginationQuery;
 
-class UI {
-    constructor(client) {
-        this.client = client;
-    }
-    async connect(options = {}) {
-        const { url, postData } = await this.client.getScreensPostData('connect', {
-            ...options,
-            allowMultipleConnections: options.allowMultipleConnections ? '1' : '',
-            connectorParameters: options.connectorParameters ? JSON.stringify(options.connectorParameters) : undefined,
-        });
-        return new Promise((resolve) => {
-            return openIframeWithPost(url, postData, {
-                onClose: () => resolve(null),
-                onSuccess: (connection) => resolve(connection),
-            });
-        });
-    }
-}
-
 const API_VERSIONS = {
     LEGACY: 'legacy',
     '2025-10-21': '2025-10-21',
@@ -15742,6 +15883,36 @@ class MembraneApiClient {
     }
 }
 
+class UI {
+    constructor(client) {
+        this.client = client;
+    }
+    async connect(options = {}) {
+        const { url, postData } = await this.client.getScreensPostData('connect', {
+            ...options,
+            allowMultipleConnections: options.allowMultipleConnections ? '1' : '',
+            connectorParameters: options.connectorParameters ? JSON.stringify(options.connectorParameters) : undefined,
+        });
+        return new Promise((resolve) => {
+            return openIframeWithPost(url, postData, {
+                onClose: () => resolve(null),
+                onSuccess: (connection) => resolve(connection),
+            });
+        });
+    }
+    async UNSAFE_agentSession(options) {
+        const { url, postData } = await this.client.getScreensPostData('agent-session', {
+            sessionId: options.sessionId,
+            theme: options.theme,
+        });
+        return new Promise((resolve) => {
+            return openIframeWithPost(url, postData, {
+                onClose: () => resolve(),
+            });
+        });
+    }
+}
+
 class MembraneClient extends MembraneApiClient {
     constructor(options) {
         super(options);