strapi-plugin-hubspot 0.16.5 → 0.16.8

package/dist/server/index.mjs

@@ -1599,6 +1599,48 @@ function missingMappedFields(definition, existingNames) {
   const existing = new Set(existingNames);
   return mappedContactFields(definition).filter((field) => !existing.has(field.property));
 }
+const OBJECT_TYPE_BY_NAME = {
+  contact: "0-1",
+  company: "0-2"
+};
+function collectedHubspotKeys(definition) {
+  const keys = /* @__PURE__ */ new Set();
+  const add = (object, property) => {
+    const typeId = OBJECT_TYPE_BY_NAME[object] || object;
+    if (property) keys.add(`${typeId}:${property}`);
+  };
+  for (const step of definition.steps ?? []) {
+    for (const fld of step.fields ?? []) {
+      if (fld.type === "company") {
+        const map = fld.companyMap ?? {};
+        for (const slot of Object.values(map)) {
+          if (slot?.property?.trim()) add(slot.object?.trim() || "company", slot.property.trim());
+        }
+        continue;
+      }
+      const mapping = fld.hubspot ?? {};
+      const object = mapping.object?.trim() || "contact";
+      const property = mapping.property?.trim() || fld.name;
+      if (property) add(object, property);
+    }
+  }
+  return keys;
+}
+function missingRequiredHubspotFields(definition, required) {
+  const collected = collectedHubspotKeys(definition);
+  const missing = [];
+  for (const field of required) {
+    if (!field.name) continue;
+    const objectTypeId = field.objectTypeId?.trim() || "0-1";
+    if (collected.has(`${objectTypeId}:${field.name}`)) continue;
+    missing.push({
+      name: field.name,
+      objectTypeId,
+      object: objectTypeId === "0-2" ? "company" : "contact"
+    });
+  }
+  return missing;
+}
 function hsFieldType(type, options) {
   switch (type) {
     case "email":
@@ -1649,6 +1691,74 @@ function appendFieldGroups(existing, extra) {
     }))
   ];
 }
+function conditionToHubspot(condition, parentId) {
+  const rules = (condition.rules ?? []).filter((rule) => rule.field === parentId);
+  if (!rules.length || rules.length !== (condition.rules ?? []).length) return null;
+  const op = rules[0]?.operator;
+  if (rules.some((rule) => rule.operator !== op)) return null;
+  const values = rules.map((rule) => rule.value).filter((value) => Boolean(value));
+  switch (op) {
+    case "eq":
+      return { operator: values.length > 1 ? "SET_ANY" : "EQ", values };
+    case "neq":
+      return { operator: values.length > 1 ? "NOT_SET_ANY" : "NEQ", values };
+    case "contains":
+      return { operator: "CONTAINS", values };
+    case "gt":
+      return { operator: "GT", values };
+    case "lt":
+      return { operator: "LT", values };
+    case "notEmpty":
+      return { operator: "SET", values: [] };
+    case "empty":
+      return { operator: "NOT_SET", values: [] };
+    default:
+      return null;
+  }
+}
+function applyVisibleIfToFieldGroups(groups, definition) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const step of definition.steps ?? []) {
+    for (const fld of step.fields ?? []) {
+      const mapping = fld.hubspot ?? {};
+      byId.set(fld.id, { name: fld.name, property: mapping.property?.trim() || fld.name });
+    }
+  }
+  const moves = /* @__PURE__ */ new Map();
+  for (const step of definition.steps ?? []) {
+    for (const fld of step.fields ?? []) {
+      const visibleIf = fld.visibleIf;
+      const parentId = visibleIf?.rules?.[0]?.field;
+      if (!visibleIf || !parentId) continue;
+      const converted = conditionToHubspot(visibleIf, parentId);
+      const parent = byId.get(parentId);
+      const mapping = fld.hubspot ?? {};
+      const property = mapping.property?.trim() || fld.name;
+      if (!converted || !parent) continue;
+      moves.set(property, { parent: parent.property, ...converted });
+    }
+  }
+  if (!moves.size) return groups;
+  const cloned = JSON.parse(JSON.stringify(groups));
+  const flat = [];
+  for (const group of cloned) {
+    (group.fields ?? []).forEach((field, index2) => flat.push({ group, index: index2, field }));
+  }
+  for (const [property, move] of moves) {
+    const child = flat.find((item) => item.field.name === property);
+    const parent = flat.find((item) => item.field.name === move.parent);
+    if (!child || !parent || child === parent) continue;
+    parent.field.dependentFields = [
+      ...parent.field.dependentFields ?? [],
+      {
+        dependentCondition: { operator: move.operator, values: move.values },
+        field: child.field
+      }
+    ];
+    child.group.fields?.splice(child.index, 1);
+  }
+  return cloned;
+}
 const HS_BASE$2 = "https://api.hubapi.com";
 const OBJECT_BY_TYPE_ID = {
   "0-1": "contact",
@@ -1730,7 +1840,7 @@ function convertField(raw, ctx) {
     helpText: raw.description || void 0,
     ...options.length ? { options } : {},
     hubspot: { object, property: name },
-    ...ctx.parentCondition ? { visibleIf: ctx.parentCondition } : {}
+    ...ctx.parentCondition ? { visibleIf: ctx.parentCondition, visibleIfSource: "hubspot" } : {}
   };
   const out = [field];
   for (const dependent of raw.dependentFields ?? []) {
@@ -1753,6 +1863,12 @@ function convertHubspotForm(raw) {
   const usedNames = /* @__PURE__ */ new Set();
   const fields = [];
   for (const group of raw.fieldGroups ?? []) {
+    if (group.groupType === "progressive" || group.groupType === "queued") {
+      skipped.push({
+        code: "progressive",
+        detail: group.groupType
+      });
+    }
     if (group.richText && !(group.fields ?? []).length) {
       skipped.push({ code: "rich-text", detail: group.richText.slice(0, 80) });
       continue;
@@ -1824,7 +1940,10 @@ function mergeHubspotImport(current, incoming) {
       existing.helpText = next.helpText;
       if (next.options) existing.options = next.options;
       else delete existing.options;
-      if (!existing.visibleIf && next.visibleIf) existing.visibleIf = next.visibleIf;
+      if (next.visibleIf && (existing.visibleIfSource === "hubspot" || !existing.visibleIf)) {
+        existing.visibleIf = next.visibleIf;
+        if (existing.visibleIfSource !== "editor") existing.visibleIfSource = "hubspot";
+      }
       updated.push(key);
       continue;
     }
@@ -1922,10 +2041,6 @@ function formsSubmitUrl(portalId, formGuid, region = "eu1") {
 function toHsFields(props) {
   return Object.entries(props).filter(([, value]) => value !== "").map(([name, value]) => ({ name, value }));
 }
-function filterToFormFields(fields, allowed) {
-  if (!allowed) return fields;
-  return fields.filter((field) => allowed.has(field.name));
-}
 function formFieldNames(raw) {
   const names = [];
   for (const group of raw.fieldGroups ?? []) {
@@ -1935,20 +2050,42 @@ function formFieldNames(raw) {
   }
   return names;
 }
-function formRequiredNames(raw) {
-  const names = [];
+const OBJECT_BAG = {
+  "0-1": "contact",
+  "0-2": "company"
+};
+function formShapeFields(raw) {
+  const fields = [];
   for (const group of raw.fieldGroups ?? []) {
     for (const field of group.fields ?? []) {
-      if (field.name && field.required) names.push(field.name);
+      if (!field.name) continue;
+      fields.push({
+        name: field.name,
+        objectTypeId: field.objectTypeId?.trim() || "0-1",
+        required: Boolean(field.required)
+      });
     }
   }
-  return names;
+  return fields;
+}
+function fieldsForHubspotForm(bags, shape, extra = {}) {
+  const contact = { ...bags.contact ?? {}, ...extra };
+  if (!shape?.fields.length) {
+    return toHsFields(contact).map((field) => ({ ...field, objectTypeId: "0-1" }));
+  }
+  const out = [];
+  for (const field of shape.fields) {
+    const bagName = OBJECT_BAG[field.objectTypeId] || "contact";
+    const value = bags[bagName]?.[field.name] ?? contact[field.name];
+    if (!value) continue;
+    out.push({ name: field.name, value, objectTypeId: field.objectTypeId || "0-1" });
+  }
+  return out;
 }
 function parseFormShape(raw) {
   const legal = raw.legalConsentOptions;
-  const hasLegalConsent = Boolean(
-    legal && typeof legal === "object" && legal.type && legal.type !== "none"
-  );
+  const legalType = typeof legal?.type === "string" ? legal.type : void 0;
+  const hasLegalConsent = Boolean(legalType && legalType !== "none");
   const communications = [];
   for (const box of legal?.communicationsCheckboxes ?? []) {
     const id = Number(box.subscriptionTypeId ?? box.communicationTypeId);
@@ -1958,12 +2095,21 @@ function parseFormShape(raw) {
       text: String(box.label || box.text || "").trim() || "I agree to receive communications."
     });
   }
+  const subscriptionTypeIds = (legal?.subscriptionTypeIds ?? []).map((id) => Number(id)).filter((id) => Number.isFinite(id) && id > 0);
   const consentToProcessText = legal?.consentToProcessText?.trim();
+  const privacyText = legal?.privacyText?.trim();
+  const lawfulRaw = String(legal?.lawfulBasis || "").toUpperCase();
+  const fields = formShapeFields(raw);
   return {
-    names: new Set(formFieldNames(raw)),
-    required: new Set(formRequiredNames(raw)),
+    names: new Set(fields.map((field) => field.name)),
+    required: new Set(fields.filter((field) => field.required).map((field) => field.name)),
+    fields,
     hasLegalConsent,
-    captcha: raw.configuration?.captchaEnabled === true,
+    ...legalType ? { legalType } : {},
+    lawfulBasis: lawfulRaw.includes("CUSTOMER") ? "CUSTOMER" : "LEAD",
+    subscriptionTypeIds,
+    ...privacyText ? { privacyText } : {},
+    captcha: raw.configuration?.recaptchaEnabled === true || raw.configuration?.captchaEnabled === true,
     ...consentToProcessText ? { consentToProcessText } : {},
     communications
   };
@@ -1975,9 +2121,22 @@ function canRetryEmailOnly(required) {
 function buildLegalConsent(shape, given, fallbackText) {
   if (!given) return void 0;
   if (shape && !shape.hasLegalConsent) return void 0;
+  const fallback = fallbackText?.trim() || DEFAULT_CONSENT_TEXT;
+  if (shape?.legalType === "legitimate_interest") {
+    const subscriptionTypeId = shape.subscriptionTypeIds[0];
+    if (!subscriptionTypeId) return void 0;
+    return {
+      legitimateInterest: {
+        value: true,
+        subscriptionTypeId,
+        legalBasis: shape.lawfulBasis || "LEAD",
+        text: shape.privacyText?.trim() || fallback
+      }
+    };
+  }
   const consent = {
     consentToProcess: true,
-    text: shape?.consentToProcessText?.trim() || fallbackText?.trim() || DEFAULT_CONSENT_TEXT
+    text: shape?.consentToProcessText?.trim() || fallback
   };
   if (shape?.communications.length) {
     consent.communications = shape.communications.map((item) => ({
@@ -2105,13 +2264,62 @@ async function submitMarketingForm(input) {
 async function syncFieldsToHubspotForm(apiKey, formGuid, definition) {
   const raw = await fetchHubspotForm(apiKey, formGuid);
   const extra = missingMappedFields(definition, formFieldNames(raw));
-  if (!extra.length) return [];
-  await patchHubspotForm(apiKey, formGuid, {
-    fieldGroups: appendFieldGroups(raw.fieldGroups ?? [], extra)
-  });
+  const fieldGroups = applyVisibleIfToFieldGroups(
+    appendFieldGroups(raw.fieldGroups ?? [], extra),
+    definition
+  );
+  if (!extra.length && JSON.stringify(fieldGroups) === JSON.stringify(appendFieldGroups(raw.fieldGroups ?? [], []))) {
+    return [];
+  }
+  await patchHubspotForm(apiKey, formGuid, { fieldGroups });
   clearFormShapeCache(formGuid);
   return extra.map((field) => field.property);
 }
+async function createMarketingForm(apiKey, name, definition) {
+  const fields = mappedContactFields(definition).map((field) => toHsFormField(field));
+  if (!fields.length) {
+    throw new Error("Add at least one mapped contact field before creating a HubSpot form");
+  }
+  const res = await fetch("https://api.hubapi.com/marketing/v3/forms", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      name,
+      formType: "hubspot",
+      fieldGroups: applyVisibleIfToFieldGroups(
+        fields.map((field) => ({
+          groupType: "default_group",
+          richTextType: "text",
+          fields: [field]
+        })),
+        definition
+      ),
+      configuration: {
+        language: "fr",
+        recaptchaEnabled: false,
+        createNewContactForNewEmail: true,
+        prePopulateKnownValues: true,
+        notifyContactOwner: false,
+        notifyRecipients: [],
+        editable: true,
+        archivable: true,
+        cloneable: true,
+        allowLinkToResetKnownValues: false,
+        postSubmitAction: { type: "thank_you", value: "Merci." }
+      },
+      displayOptions: { submitButtonText: "Envoyer", style: { submitButtonText: "Envoyer" } },
+      legalConsentOptions: { type: "none" }
+    })
+  });
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok || !body.id) {
+    throw new Error(body.message || `HubSpot ${res.status}`);
+  }
+  return body.id;
+}
 function publicForm(entry) {
   return {
     slug: entry.slug,
@@ -2125,7 +2333,9 @@ function publicForm(entry) {
     steps: (entry.definition?.steps ?? []).map((step) => ({
       ...step,
       // The CRM mappings are the server's business — never the browser's.
-      fields: (step.fields ?? []).map(({ hubspot: _hubspot, companyMap: _companyMap, ...fld }) => fld)
+      fields: (step.fields ?? []).map(
+        ({ hubspot: _hubspot, companyMap: _companyMap, visibleIfSource: _source, ...fld }) => fld
+      )
     }))
   };
 }
@@ -2499,12 +2709,16 @@ function createFormsService(strapi, _opts = {}) {
       if (tryFormsApi && portalId && formGuid) {
         try {
           const shape = await loadFormShape(apiKey, formGuid);
-          const fields = filterToFormFields(
-            toHsFields({ ...contactProps, email }),
-            shape?.names ?? null
+          const fields = fieldsForHubspotForm(
+            {
+              contact: contactProps,
+              company: stringProps(partition.accepted.company ?? {})
+            },
+            shape,
+            { email }
           );
           if (fields.length && !fields.some((f) => f.name === "email")) {
-            fields.unshift({ name: "email", value: email });
+            fields.unshift({ name: "email", value: email, objectTypeId: "0-1" });
           }
           sentFieldNames = fields.map((f) => f.name);
           const submitted = await submitMarketingForm({
@@ -2512,7 +2726,7 @@ function createFormsService(strapi, _opts = {}) {
             portalId,
             formGuid,
             region,
-            fields: fields.length ? fields : [{ name: "email", value: email }],
+            fields: fields.length ? fields : [{ name: "email", value: email, objectTypeId: "0-1" }],
             context: {
               hutk: sanitizeHutk(meta.hutk),
               pageUri: typeof meta.pageUrl === "string" ? meta.pageUrl : void 0,
@@ -2865,6 +3079,22 @@ function createFormsAdminController(strapi) {
         ctx.body = { errors: structural, problems: mappings };
         return;
       }
+      const { apiKey } = await resolveApiKey(strapi);
+      const account = await resolveAccount(strapi);
+      const ownGuid = typeof entry.hubspotFormId === "string" ? entry.hubspotFormId.trim() : "";
+      const formGuid = isFormGuid(ownGuid) ? ownGuid : isFormGuid(account.defaultFormId) ? account.defaultFormId.trim() : "";
+      if (apiKey && formGuid) {
+        const shape = await loadFormShape(apiKey, formGuid);
+        const missingHubspot = shape ? missingRequiredHubspotFields(
+          entry.definition ?? EMPTY_DEFINITION,
+          [...shape.fields.filter((field) => field.required)]
+        ) : [];
+        if (missingHubspot.length) {
+          ctx.status = 400;
+          ctx.body = { errors: structural, problems: mappings, missingHubspot };
+          return;
+        }
+      }
       await documents().publish({
         documentId: ctx.params.documentId,
         locale: ctx.query.locale
@@ -2872,22 +3102,16 @@ function createFormsAdminController(strapi) {
       const policy = await resolvePolicy(strapi);
       let addedFields = [];
       let syncWarning;
-      if (policy.syncFieldsOnPublish) {
-        const { apiKey } = await resolveApiKey(strapi);
-        const account = await resolveAccount(strapi);
-        const ownGuid = typeof entry.hubspotFormId === "string" ? entry.hubspotFormId.trim() : "";
-        const formGuid = isFormGuid(ownGuid) ? ownGuid : isFormGuid(account.defaultFormId) ? account.defaultFormId.trim() : "";
-        if (apiKey && formGuid) {
-          try {
-            addedFields = await syncFieldsToHubspotForm(
-              apiKey,
-              formGuid,
-              entry.definition ?? EMPTY_DEFINITION
-            );
-          } catch (err) {
-            syncWarning = err.message;
-            strapi.log.warn(`[hubspot] field sync on publish failed — ${syncWarning}`);
-          }
+      if (policy.syncFieldsOnPublish && apiKey && formGuid) {
+        try {
+          addedFields = await syncFieldsToHubspotForm(
+            apiKey,
+            formGuid,
+            entry.definition ?? EMPTY_DEFINITION
+          );
+        } catch (err) {
+          syncWarning = err.message;
+          strapi.log.warn(`[hubspot] field sync on publish failed — ${syncWarning}`);
         }
       }
       ctx.body = {
@@ -2896,6 +3120,31 @@ function createFormsAdminController(strapi) {
         ...syncWarning ? { syncWarning } : {}
       };
     },
+    async createInHubspot(ctx) {
+      const entry = await documents().findOne({
+        documentId: ctx.params.documentId,
+        locale: ctx.query.locale,
+        status: "draft"
+      });
+      if (!entry) ctx.throw(404, "Form not found");
+      const { apiKey } = await resolveApiKey(strapi);
+      if (!apiKey) ctx.throw(400, "HubSpot API key is missing");
+      try {
+        const id = await createMarketingForm(
+          apiKey,
+          entry.name || entry.slug || "Formulaire",
+          entry.definition ?? EMPTY_DEFINITION
+        );
+        const updated = await documents().update({
+          documentId: ctx.params.documentId,
+          locale: ctx.query.locale,
+          data: { hubspotFormId: id }
+        });
+        ctx.body = { form: updated, hubspotFormId: id };
+      } catch (err) {
+        ctx.throw(400, err.message);
+      }
+    },
     async unpublish(ctx) {
       await documents().unpublish({
         documentId: ctx.params.documentId,
@@ -3662,6 +3911,7 @@ const routes = {
       adminRoute("GET", "/builder/forms/:documentId", "formsAdmin.findOne", [FORMS_ACTION]),
       adminRoute("PUT", "/builder/forms/:documentId", "formsAdmin.update", [FORMS_ACTION]),
       adminRoute("POST", "/builder/forms/:documentId/publish", "formsAdmin.publish", [FORMS_ACTION]),
+      adminRoute("POST", "/builder/forms/:documentId/create-hubspot", "formsAdmin.createInHubspot", [FORMS_ACTION]),
       adminRoute("POST", "/builder/forms/:documentId/unpublish", "formsAdmin.unpublish", [FORMS_ACTION]),
       adminRoute("DELETE", "/builder/forms/:documentId", "formsAdmin.remove", [FORMS_ACTION]),
       adminRoute("POST", "/builder/forms/:documentId/duplicate", "formsAdmin.duplicate", [FORMS_ACTION]),

package/dist/server/src/conditions.d.ts

@@ -22,6 +22,7 @@ export interface FormFieldDef {
     type: string;
     required?: boolean;
     visibleIf?: Condition | null;
+    visibleIfSource?: "hubspot" | "editor" | null;
     [key: string]: unknown;
 }
 export interface FormStepDef {

package/dist/server/src/formSync.d.ts

@@ -26,6 +26,21 @@ export interface MappedFormField {
 export declare function leftoverContactProps(contact: Record<string, string>, sentFieldNames: Iterable<string>): Record<string, string>;
 export declare function mappedContactFields(definition: FormDefinition): MappedFormField[];
 export declare function missingMappedFields(definition: FormDefinition, existingNames: Iterable<string>): MappedFormField[];
+export interface MissingHubspotRequired {
+    name: string;
+    objectTypeId: string;
+    object: string;
+}
+/** Properties the Strapi form can actually send (`objectTypeId:property`). */
+export declare function collectedHubspotKeys(definition: FormDefinition): Set<string>;
+/**
+ * Required marketing-form fields the Strapi form never collects. HubSpot
+ * rejects the whole conversion when one of these is absent.
+ */
+export declare function missingRequiredHubspotFields(definition: FormDefinition, required: {
+    name: string;
+    objectTypeId?: string;
+}[]): MissingHubspotRequired[];
 export declare function hsFieldType(type: string, options?: unknown[]): string;
 export declare function toHsFormField(field: MappedFormField): Record<string, unknown>;
 export interface RawFieldGroupLike {
@@ -35,3 +50,8 @@ export interface RawFieldGroupLike {
     fields?: unknown[];
 }
 export declare function appendFieldGroups(existing: RawFieldGroupLike[], extra: MappedFormField[]): Record<string, unknown>[];
+/**
+ * Nest Strapi `visibleIf` fields under their HubSpot parent as dependentFields.
+ * Conditions edited in Strapi are included; unsupported multi-parent rules stay flat.
+ */
+export declare function applyVisibleIfToFieldGroups(groups: Record<string, unknown>[], definition: FormDefinition): Record<string, unknown>[];

package/dist/server/src/formsAdmin.d.ts

@@ -26,6 +26,7 @@ export declare function createFormsAdminController(strapi: Core.Strapi): {
     create(ctx: Ctx): Promise<void>;
     update(ctx: Ctx): Promise<void>;
     publish(ctx: Ctx): Promise<void>;
+    createInHubspot(ctx: Ctx): Promise<void>;
     unpublish(ctx: Ctx): Promise<void>;
     /**
      * Feeds the `hubspot.form-picker` custom field: every form of the builder

package/dist/server/src/hsforms.d.ts

@@ -23,13 +23,9 @@ export declare function toHsFields(props: Record<string, string>): {
     name: string;
     value: string;
 }[];
-export declare function filterToFormFields(fields: {
+export declare function filterToFormFields<T extends {
     name: string;
-    value: string;
-}[], allowed: Set<string> | null): {
-    name: string;
-    value: string;
-}[];
+}>(fields: T[], allowed: Set<string> | null): T[];
 export declare function formFieldNames(raw: {
     fieldGroups?: {
         fields?: {
@@ -50,26 +46,56 @@ export interface CommunicationConsent {
     subscriptionTypeId: number;
     text: string;
 }
+export interface FormShapeField {
+    name: string;
+    objectTypeId: string;
+    required: boolean;
+}
 export interface FormShape {
     names: Set<string>;
     required: Set<string>;
+    fields: FormShapeField[];
     hasLegalConsent: boolean;
+    legalType?: string;
+    lawfulBasis?: "LEAD" | "CUSTOMER";
+    subscriptionTypeIds: number[];
+    privacyText?: string;
     captcha: boolean;
     consentToProcessText?: string;
     communications: CommunicationConsent[];
 }
+export declare function formShapeFields(raw: {
+    fieldGroups?: {
+        fields?: {
+            name?: string;
+            required?: boolean;
+            objectTypeId?: string;
+        }[];
+    }[];
+}): FormShapeField[];
+/** Values HubSpot declared on the marketing form, with the right objectTypeId. */
+export declare function fieldsForHubspotForm(bags: Record<string, Record<string, string>>, shape: FormShape | null | undefined, extra?: Record<string, string>): {
+    name: string;
+    value: string;
+    objectTypeId: string;
+}[];
 export declare function parseFormShape(raw: {
     fieldGroups?: {
         fields?: {
             name?: string;
             required?: boolean;
+            objectTypeId?: string;
         }[];
     }[];
     configuration?: {
         captchaEnabled?: boolean;
+        recaptchaEnabled?: boolean;
     };
     legalConsentOptions?: {
         type?: string;
+        lawfulBasis?: string;
+        privacyText?: string;
+        subscriptionTypeIds?: (number | string)[];
         consentToProcessText?: string;
         communicationsCheckboxes?: {
             label?: string;
@@ -81,7 +107,7 @@ export declare function parseFormShape(raw: {
 }): FormShape;
 /** Email-only retry is only safe when HubSpot doesn't require other fields. */
 export declare function canRetryEmailOnly(required: Iterable<string> | undefined): boolean;
-export declare function buildLegalConsent(shape: Pick<FormShape, "hasLegalConsent" | "communications" | "consentToProcessText"> | null | undefined, given: boolean, fallbackText?: string): Record<string, unknown> | undefined;
+export declare function buildLegalConsent(shape: Pick<FormShape, "hasLegalConsent" | "legalType" | "lawfulBasis" | "subscriptionTypeIds" | "privacyText" | "communications" | "consentToProcessText"> | null | undefined, given: boolean, fallbackText?: string): Record<string, unknown> | undefined;
 export interface FormSubmitContext {
     hutk?: string;
     pageUri?: string;
@@ -127,3 +153,5 @@ export declare function submitMarketingForm(input: FormSubmitInput): Promise<{
  * that already exist. Returns the property names that were added.
  */
 export declare function syncFieldsToHubspotForm(apiKey: string, formGuid: string, definition: FormDefinition): Promise<string[]>;
+/** Create a marketing form from the Strapi definition and return its GUID. */
+export declare function createMarketingForm(apiKey: string, name: string, definition: FormDefinition): Promise<string>;

package/dist/server/src/importHubspot.d.ts

@@ -21,7 +21,7 @@ export interface HubspotFormSummary {
 }
 /** Something the converter could not express in the builder's model. */
 export interface SkippedItem {
-    code: "field-type" | "hidden-field" | "object" | "duplicate" | "condition" | "rich-text" | "legal-consent";
+    code: "field-type" | "hidden-field" | "object" | "duplicate" | "condition" | "rich-text" | "legal-consent" | "progressive";
     /** Field label or name, when the item is a field. */
     label?: string;
     /** Raw detail (the fieldType, the operator…) for the report. */
@@ -58,6 +58,7 @@ interface RawField {
     dependentFields?: RawDependent[];
 }
 interface RawFieldGroup {
+    groupType?: string;
     richText?: string;
     fields?: RawField[];
 }

package/dist/server/src/index.d.ts

@@ -274,6 +274,7 @@ declare const _default: {
             create(ctx: import("./formsAdmin").Ctx): Promise<void>;
             update(ctx: import("./formsAdmin").Ctx): Promise<void>;
             publish(ctx: import("./formsAdmin").Ctx): Promise<void>;
+            createInHubspot(ctx: import("./formsAdmin").Ctx): Promise<void>;
             unpublish(ctx: import("./formsAdmin").Ctx): Promise<void>;
             options(ctx: import("./formsAdmin").Ctx): Promise<void>;
             listSources(ctx: import("./formsAdmin").Ctx): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strapi-plugin-hubspot",
-  "version": "0.16.5",
+  "version": "0.16.8",
   "description": "The form builder for HubSpot in Strapi — multi-step forms with conditional fields mapped to real CRM properties, a public submit pipeline with retries, and save-time mapping validation.",
   "keywords": [
     "strapi",