@membranehq/sdk 0.17.5 → 0.17.6

package/dist/index.browser.js

@@ -4024,6 +4024,97 @@ class ConnectionSpec {
     }
 }
 
+exports.FunctionType = void 0;
+(function (FunctionType) {
+    FunctionType["mapping"] = "mapping";
+    FunctionType["operationMapping"] = "operation-mapping";
+    FunctionType["restApiMapping"] = "rest-api-mapping";
+    FunctionType["graphqlApiMapping"] = "graphql-api-mapping";
+    FunctionType["javascript"] = "javascript";
+})(exports.FunctionType || (exports.FunctionType = {}));
+const BaseFunctionDefinition = z.z.object({
+    type: z.z.enum([
+        exports.FunctionType.mapping,
+        exports.FunctionType.operationMapping,
+        exports.FunctionType.restApiMapping,
+        exports.FunctionType.graphqlApiMapping,
+        exports.FunctionType.javascript,
+    ]),
+});
+const GenericFunctionDefinition = z.z
+    .object({
+    type: z.z.enum(['mapping', 'operation-mapping', 'rest-api-mapping', 'graphql-api-mapping', 'javascript']).optional(),
+})
+    .loose();
+
+const GraphQLFieldMappingSchema = z.z.lazy(() => z.z.object({
+    field: z.z.string(),
+    args: z.z.record(z.z.string(), z.z.any()).optional(),
+    subFields: z.z.array(GraphQLFieldMappingSchema).optional(),
+}));
+const GraphQLApiMappingSchema = z.z.object({
+    path: z.z.string(),
+    operationType: z.z.enum(['query', 'mutation']),
+    requestMapping: z.z.array(GraphQLFieldMappingSchema),
+    responseMapping: z.z.any().optional(),
+});
+const GraphqlApiMappingFunction = z.z.object({
+    type: z.z.literal(exports.FunctionType.graphqlApiMapping),
+    mapping: GraphQLApiMappingSchema,
+});
+
+const JavascriptFunction = z.z.object({
+    type: z.z.literal(exports.FunctionType.javascript),
+    code: z.z.string(),
+});
+
+const MappingSchema = z.z.any();
+const MappingFunction = z.z.object({
+    type: z.z.literal(exports.FunctionType.mapping),
+    mapping: MappingSchema,
+});
+
+const OperationMappingSchema = z.z.object({
+    operationKey: z.z.string(),
+    inputMapping: z.z.any().optional(),
+    outputMapping: z.z.any().optional(),
+});
+const OperationMappingFunction = z.z.object({
+    type: z.z.literal(exports.FunctionType.operationMapping),
+    mapping: OperationMappingSchema,
+});
+
+const RequestMappingSchema = z.z.object({
+    pathParameters: z.z.any().optional(),
+    query: z.z.any().optional(),
+    data: z.z.any().optional(),
+    headers: z.z.any().optional(),
+});
+const RestApiMappingSchema = z.z.object({
+    path: z.z.string(),
+    method: z.z.string(),
+    requestMapping: RequestMappingSchema,
+    responseMapping: z.z.any().optional(),
+});
+const OpenapiMappingSchema = z.z.object({
+    path: z.z.string(),
+    method: z.z.string(),
+    requestMapping: RequestMappingSchema,
+    responseMapping: z.z.any().optional(),
+});
+const RestApiMappingFunction = z.z.object({
+    type: z.z.literal(exports.FunctionType.restApiMapping),
+    mapping: RestApiMappingSchema,
+});
+
+const FunctionDefinition = z.z.union([
+    MappingFunction,
+    OperationMappingFunction,
+    RestApiMappingFunction,
+    GraphqlApiMappingFunction,
+    JavascriptFunction,
+]);
+
 exports.ConnectorMethodImplementationType = void 0;
 (function (ConnectorMethodImplementationType) {
     ConnectorMethodImplementationType["mapping"] = "mapping";
@@ -4420,97 +4511,6 @@ const REST_API_CLIENT_SCHEMA$1 = {
     },
 };
 
-exports.FunctionType = void 0;
-(function (FunctionType) {
-    FunctionType["mapping"] = "mapping";
-    FunctionType["operationMapping"] = "operation-mapping";
-    FunctionType["restApiMapping"] = "rest-api-mapping";
-    FunctionType["graphqlApiMapping"] = "graphql-api-mapping";
-    FunctionType["javascript"] = "javascript";
-})(exports.FunctionType || (exports.FunctionType = {}));
-const BaseFunctionDefinition = z.z.object({
-    type: z.z.enum([
-        exports.FunctionType.mapping,
-        exports.FunctionType.operationMapping,
-        exports.FunctionType.restApiMapping,
-        exports.FunctionType.graphqlApiMapping,
-        exports.FunctionType.javascript,
-    ]),
-});
-const GenericFunctionDefinition = z.z
-    .object({
-    type: z.z.enum(['mapping', 'operation-mapping', 'rest-api-mapping', 'graphql-api-mapping', 'javascript']).optional(),
-})
-    .loose();
-
-const GraphQLFieldMappingSchema = z.z.lazy(() => z.z.object({
-    field: z.z.string(),
-    args: z.z.record(z.z.string(), z.z.any()).optional(),
-    subFields: z.z.array(GraphQLFieldMappingSchema).optional(),
-}));
-const GraphQLApiMappingSchema = z.z.object({
-    path: z.z.string(),
-    operationType: z.z.enum(['query', 'mutation']),
-    requestMapping: z.z.array(GraphQLFieldMappingSchema),
-    responseMapping: z.z.any().optional(),
-});
-const GraphqlApiMappingFunction = z.z.object({
-    type: z.z.literal(exports.FunctionType.graphqlApiMapping),
-    mapping: GraphQLApiMappingSchema,
-});
-
-const JavascriptFunction = z.z.object({
-    type: z.z.literal(exports.FunctionType.javascript),
-    code: z.z.string(),
-});
-
-const MappingSchema = z.z.any();
-const MappingFunction = z.z.object({
-    type: z.z.literal(exports.FunctionType.mapping),
-    mapping: MappingSchema,
-});
-
-const OperationMappingSchema = z.z.object({
-    operationKey: z.z.string(),
-    inputMapping: z.z.any().optional(),
-    outputMapping: z.z.any().optional(),
-});
-const OperationMappingFunction = z.z.object({
-    type: z.z.literal(exports.FunctionType.operationMapping),
-    mapping: OperationMappingSchema,
-});
-
-const RequestMappingSchema = z.z.object({
-    pathParameters: z.z.any().optional(),
-    query: z.z.any().optional(),
-    data: z.z.any().optional(),
-    headers: z.z.any().optional(),
-});
-const RestApiMappingSchema = z.z.object({
-    path: z.z.string(),
-    method: z.z.string(),
-    requestMapping: RequestMappingSchema,
-    responseMapping: z.z.any().optional(),
-});
-const OpenapiMappingSchema = z.z.object({
-    path: z.z.string(),
-    method: z.z.string(),
-    requestMapping: RequestMappingSchema,
-    responseMapping: z.z.any().optional(),
-});
-const RestApiMappingFunction = z.z.object({
-    type: z.z.literal(exports.FunctionType.restApiMapping),
-    mapping: RestApiMappingSchema,
-});
-
-const FunctionDefinition = z.z.union([
-    MappingFunction,
-    OperationMappingFunction,
-    RestApiMappingFunction,
-    GraphqlApiMappingFunction,
-    JavascriptFunction,
-]);
-
 const CONNECTOR_DATA_DIR = 'data';
 const CONNECTOR_OPERATIONS_DIR = 'operations';
 const CONNECTOR_DOCS_DIR = 'docs';
@@ -4686,369 +4686,528 @@ exports.DataCollectionEventType = void 0;
     DataCollectionEventType["DELETED"] = "deleted";
 })(exports.DataCollectionEventType || (exports.DataCollectionEventType = {}));
 
-const DataLocationMethodImplementationTypes = [
-    exports.ConnectorMethodImplementationType.operationMapping,
-    exports.ConnectorMethodImplementationType.restApiMapping,
-    exports.ConnectorMethodImplementationType.graphqlApiMapping,
-    exports.ConnectorMethodImplementationType.javascript,
-    exports.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);
-        }
-        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 }) => {
+function getDataLocationMethodPath(locationKey, methodKey) {
+    return `data/${locationKey}/${jsConvertCase.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({
-                id: {
-                    type: 'string',
-                    referenceCollection: { key: collectionHandler === null || collectionHandler === void 0 ? void 0 : collectionHandler.key, parameters },
-                },
-                credentials: credentialsSchema,
-            }),
+            key: pointer.slice(6),
         };
-    },
-    getOutputSchema: () => null,
-    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 !== exports.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 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 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' },
                 },
             },
-        };
+        },
+        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,
+        },
     },
-    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;
+};
+const FallbackFieldsMap = {
+    fromActivitiesToTasks: {
+        subject: {
+            $var: 'title',
+        },
+        content: {
+            $var: 'description',
+        },
     },
-    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',
-                },
-            },
-        });
+    fromTasksToActivities: {
+        title: {
+            $var: 'subject',
+        },
+        description: {
+            $var: 'content',
+        },
+    },
+    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',
@@ -5057,10 +5216,6 @@ const FIELDS_SCHEMA$G = {
             type: 'string',
             format: 'date-time',
         },
-        dueTime: {
-            type: 'string',
-            format: 'date-time',
-        },
         createdTime: {
             type: 'string',
             format: 'date-time',
@@ -5081,477 +5236,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',
@@ -7969,173 +7814,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}/${jsConvertCase.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 !== exports.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);
-}
-
 exports.UDM = void 0;
 (function (UDM) {
     UDM["ACTIVITIES"] = "activities";
@@ -8270,113 +7948,435 @@ function findUdmDefaultCollection(spec, udm, useFallback = true) {
     }
     if ((_h = (_g = (_f = (_e = spec.udm) === null || _e === void 0 ? void 0 : _e[udm]) === null || _f === void 0 ? void 0 : _f.collectionMappings) === null || _g === void 0 ? void 0 : _g[0]) === null || _h === void 0 ? void 0 : _h.key) {
         return {
-            key: spec.udm[udm].collectionMappings[0].key,
+            key: spec.udm[udm].collectionMappings[0].key,
+        };
+    }
+    const udmSpec = UNIFIED_DATA_MODELS[udm];
+    if (!udmSpec) {
+        throw new BadRequestError(`Unknown UDM: ${udm}`);
+    }
+    if (useFallback) {
+        for (const fallback of (_j = udmSpec.udmFallbacks) !== null && _j !== void 0 ? _j : []) {
+            const pointer = findUdmDefaultCollection(spec, fallback.udm, false);
+            if (pointer) {
+                return pointer;
+            }
+        }
+    }
+    return undefined;
+}
+function addUdmFallbackFields(fields, udm) {
+    if (!udm) {
+        return fields;
+    }
+    const udmSpec = UNIFIED_DATA_MODELS[udm];
+    if (!udmSpec) {
+        throw new BadRequestError(`Unknown UDM: ${udm}`);
+    }
+    if (!udmSpec.fieldFallbacks) {
+        return fields;
+    }
+    let result = structuredClone$1(fields);
+    for (const fieldKeyWithFallbacks of Object.keys(udmSpec.fieldFallbacks)) {
+        const currentValue = getValueAtLocator(fields, fieldKeyWithFallbacks);
+        if (currentValue !== undefined)
+            continue;
+        for (const fallbackValue of udmSpec.fieldFallbacks[fieldKeyWithFallbacks]) {
+            const varFormulaLocators = getVariableLocators(fallbackValue);
+            const varLocators = [];
+            for (const varFormulaLocator of varFormulaLocators) {
+                const formula = exports.getFormula(getValueAtLocator(fallbackValue, varFormulaLocator));
+                varLocators.push(formula.locator);
+            }
+            const fallbackValueHasDependencies = varLocators.some((locator) => getValueAtLocator(fields, locator) !== undefined);
+            if (fallbackValueHasDependencies) {
+                result = setValueAtLocator(result, fieldKeyWithFallbacks, transformVars(fallbackValue, fields));
+                break;
+            }
+        }
+    }
+    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',
+        },
+    },
+};
+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 = [
+    exports.ConnectorMethodImplementationType.operationMapping,
+    exports.ConnectorMethodImplementationType.restApiMapping,
+    exports.ConnectorMethodImplementationType.graphqlApiMapping,
+    exports.ConnectorMethodImplementationType.javascript,
+    exports.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 },
+                },
+            },
         };
-    }
-    const udmSpec = UNIFIED_DATA_MODELS[udm];
-    if (!udmSpec) {
-        throw new BadRequestError(`Unknown UDM: ${udm}`);
-    }
-    if (useFallback) {
-        for (const fallback of (_j = udmSpec.udmFallbacks) !== null && _j !== void 0 ? _j : []) {
-            const pointer = findUdmDefaultCollection(spec, fallback.udm, false);
-            if (pointer) {
-                return pointer;
-            }
-        }
-    }
-    return undefined;
-}
-function addUdmFallbackFields(fields, udm) {
-    if (!udm) {
-        return fields;
-    }
-    const udmSpec = UNIFIED_DATA_MODELS[udm];
-    if (!udmSpec) {
-        throw new BadRequestError(`Unknown UDM: ${udm}`);
-    }
-    if (!udmSpec.fieldFallbacks) {
-        return fields;
-    }
-    let result = structuredClone$1(fields);
-    for (const fieldKeyWithFallbacks of Object.keys(udmSpec.fieldFallbacks)) {
-        const currentValue = getValueAtLocator(fields, fieldKeyWithFallbacks);
-        if (currentValue !== undefined)
-            continue;
-        for (const fallbackValue of udmSpec.fieldFallbacks[fieldKeyWithFallbacks]) {
-            const varFormulaLocators = getVariableLocators(fallbackValue);
-            const varLocators = [];
-            for (const varFormulaLocator of varFormulaLocators) {
-                const formula = exports.getFormula(getValueAtLocator(fallbackValue, varFormulaLocator));
-                varLocators.push(formula.locator);
-            }
-            const fallbackValueHasDependencies = varLocators.some((locator) => getValueAtLocator(fields, locator) !== undefined);
-            if (fallbackValueHasDependencies) {
-                result = setValueAtLocator(result, fieldKeyWithFallbacks, transformVars(fallbackValue, fields));
-                break;
-            }
-        }
-    }
-    return result;
-}
+    },
+    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 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 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',
@@ -15491,25 +15491,6 @@ const CreateClusterRequest = z.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',
@@ -15761,6 +15742,25 @@ 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),
+            });
+        });
+    }
+}
+
 class MembraneClient extends MembraneApiClient {
     constructor(options) {
         super(options);