@outseta/api-client 0.3.38 → 0.3.40

package/dist/index.js

@@ -674,6 +674,53 @@ var registrationRegisterAccount = async (account, options) => {
     body: JSON.stringify(account)
   });
 };
+var getSegmentAddTagToEntityUrl = (entityUid) => {
+  return `/api/v1/crm/segments/${entityUid}/tags`;
+};
+var segmentAddTagToEntity = async (entityUid, segmentAddTagToEntityBody, options) => {
+  return customFetch(getSegmentAddTagToEntityUrl(entityUid), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(segmentAddTagToEntityBody)
+  });
+};
+var getSegmentGetTagsForEntityUrl = (entityUid, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v1/crm/segments/${entityUid}/tags?${stringifiedParams}` : `/api/v1/crm/segments/${entityUid}/tags`;
+};
+var segmentGetTagsForEntity = async (entityUid, params, options) => {
+  return customFetch(getSegmentGetTagsForEntityUrl(entityUid, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getSegmentSetTagsForEntityUrl = (entityUid) => {
+  return `/api/v1/crm/segments/${entityUid}/tags`;
+};
+var segmentSetTagsForEntity = async (entityUid, segmentSetTagsForEntityBody, options) => {
+  return customFetch(getSegmentSetTagsForEntityUrl(entityUid), {
+    ...options,
+    method: "PUT",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(segmentSetTagsForEntityBody)
+  });
+};
+var getSegmentRemoveTagFromEntityUrl = (entityUid, tagUid) => {
+  return `/api/v1/crm/segments/${entityUid}/tags/${tagUid}`;
+};
+var segmentRemoveTagFromEntity = async (entityUid, tagUid, options) => {
+  return customFetch(getSegmentRemoveTagFromEntityUrl(entityUid, tagUid), {
+    ...options,
+    method: "DELETE"
+  });
+};
 var getAccountGetAllAccountsUrl = (params) => {
   const normalizedParams = new URLSearchParams;
   Object.entries(params || {}).forEach(([key, value]) => {
@@ -1099,6 +1146,53 @@ var campaignSendTestCampaignEmail = async (campaignSendTestCampaignEmailBody, op
     body: JSON.stringify(campaignSendTestCampaignEmailBody)
   });
 };
+var getCampaignAddTagToEntityUrl = (entityUid) => {
+  return `/api/v1/email/campaigns/broadcasts/${entityUid}/tags`;
+};
+var campaignAddTagToEntity = async (entityUid, campaignAddTagToEntityBody, options) => {
+  return customFetch(getCampaignAddTagToEntityUrl(entityUid), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(campaignAddTagToEntityBody)
+  });
+};
+var getCampaignGetTagsForEntityUrl = (entityUid, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v1/email/campaigns/broadcasts/${entityUid}/tags?${stringifiedParams}` : `/api/v1/email/campaigns/broadcasts/${entityUid}/tags`;
+};
+var campaignGetTagsForEntity = async (entityUid, params, options) => {
+  return customFetch(getCampaignGetTagsForEntityUrl(entityUid, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getCampaignSetTagsForEntityUrl = (entityUid) => {
+  return `/api/v1/email/campaigns/broadcasts/${entityUid}/tags`;
+};
+var campaignSetTagsForEntity = async (entityUid, campaignSetTagsForEntityBody, options) => {
+  return customFetch(getCampaignSetTagsForEntityUrl(entityUid), {
+    ...options,
+    method: "PUT",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(campaignSetTagsForEntityBody)
+  });
+};
+var getCampaignRemoveTagFromEntityUrl = (entityUid, tagUid) => {
+  return `/api/v1/email/campaigns/broadcasts/${entityUid}/tags/${tagUid}`;
+};
+var campaignRemoveTagFromEntity = async (entityUid, tagUid, options) => {
+  return customFetch(getCampaignRemoveTagFromEntityUrl(entityUid, tagUid), {
+    ...options,
+    method: "DELETE"
+  });
+};
 var getEmailListGetAllEmailListsUrl = (params) => {
   const normalizedParams = new URLSearchParams;
   Object.entries(params || {}).forEach(([key, value]) => {
@@ -1300,6 +1394,53 @@ var articleGetArticle = async (articleUid, options) => {
     method: "GET"
   });
 };
+var getArticleAddTagToEntityUrl = (entityUid) => {
+  return `/api/v1/support/articles/${entityUid}/tags`;
+};
+var articleAddTagToEntity = async (entityUid, articleAddTagToEntityBody, options) => {
+  return customFetch(getArticleAddTagToEntityUrl(entityUid), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(articleAddTagToEntityBody)
+  });
+};
+var getArticleGetTagsForEntityUrl = (entityUid, params) => {
+  const normalizedParams = new URLSearchParams;
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/api/v1/support/articles/${entityUid}/tags?${stringifiedParams}` : `/api/v1/support/articles/${entityUid}/tags`;
+};
+var articleGetTagsForEntity = async (entityUid, params, options) => {
+  return customFetch(getArticleGetTagsForEntityUrl(entityUid, params), {
+    ...options,
+    method: "GET"
+  });
+};
+var getArticleSetTagsForEntityUrl = (entityUid) => {
+  return `/api/v1/support/articles/${entityUid}/tags`;
+};
+var articleSetTagsForEntity = async (entityUid, articleSetTagsForEntityBody, options) => {
+  return customFetch(getArticleSetTagsForEntityUrl(entityUid), {
+    ...options,
+    method: "PUT",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(articleSetTagsForEntityBody)
+  });
+};
+var getArticleRemoveTagFromEntityUrl = (entityUid, tagUid) => {
+  return `/api/v1/support/articles/${entityUid}/tags/${tagUid}`;
+};
+var articleRemoveTagFromEntity = async (entityUid, tagUid, options) => {
+  return customFetch(getArticleRemoveTagFromEntityUrl(entityUid, tagUid), {
+    ...options,
+    method: "DELETE"
+  });
+};
 var getCategoryGetAllCategoriesUrl = (params) => {
   const normalizedParams = new URLSearchParams;
   Object.entries(params || {}).forEach(([key, value]) => {
@@ -1728,7 +1869,8 @@ var EntityType = {
   AddOn: 9,
   Task: 10,
   Segment: 11,
-  Broadcast: 12
+  Broadcast: 12,
+  Article: 13
 };
 // src/generated/models/lineItemType.ts
 var LineItemType = {
@@ -2030,14 +2172,22 @@ export {
   activityAddCustomActivity,
   activityGetAll,
   articleAddArticle,
+  articleAddTagToEntity,
   articleGetAllArticles,
   articleGetArticle,
+  articleGetTagsForEntity,
+  articleRemoveTagFromEntity,
+  articleSetTagsForEntity,
   campaignAddBroadcastEmail,
+  campaignAddTagToEntity,
   campaignArchiveBroadcastCampaign,
   campaignDeleteBroadcastCampaign,
   campaignGetAllBroadcastEmails,
   campaignGetBroadcastEmail,
+  campaignGetTagsForEntity,
+  campaignRemoveTagFromEntity,
   campaignSendTestCampaignEmail,
+  campaignSetTagsForEntity,
   campaignUnscheduleBroadcastEmail,
   campaignUpdateBroadcastEmail,
   caseAddCase,
@@ -2094,14 +2244,22 @@ export {
   getActivityAddCustomActivityUrl,
   getActivityGetAllUrl,
   getArticleAddArticleUrl,
+  getArticleAddTagToEntityUrl,
   getArticleGetAllArticlesUrl,
   getArticleGetArticleUrl,
+  getArticleGetTagsForEntityUrl,
+  getArticleRemoveTagFromEntityUrl,
+  getArticleSetTagsForEntityUrl,
   getCampaignAddBroadcastEmailUrl,
+  getCampaignAddTagToEntityUrl,
   getCampaignArchiveBroadcastCampaignUrl,
   getCampaignDeleteBroadcastCampaignUrl,
   getCampaignGetAllBroadcastEmailsUrl,
   getCampaignGetBroadcastEmailUrl,
+  getCampaignGetTagsForEntityUrl,
+  getCampaignRemoveTagFromEntityUrl,
   getCampaignSendTestCampaignEmailUrl,
+  getCampaignSetTagsForEntityUrl,
   getCampaignUnscheduleBroadcastEmailUrl,
   getCampaignUpdateBroadcastEmailUrl,
   getCaseAddCaseUrl,
@@ -2170,6 +2328,10 @@ export {
   getPlanGetPlanUrl,
   getPlanUpdatePlanUrl,
   getRegistrationRegisterAccountUrl,
+  getSegmentAddTagToEntityUrl,
+  getSegmentGetTagsForEntityUrl,
+  getSegmentRemoveTagFromEntityUrl,
+  getSegmentSetTagsForEntityUrl,
   getSubscriptionAddDiscountToSubscriptionUrl,
   getSubscriptionAddOnAddSubscriptionAddOnPreviewUrl,
   getSubscriptionAddOnAddSubscriptionAddOnUrl,
@@ -2219,6 +2381,10 @@ export {
   planGetPlan,
   planUpdatePlan,
   registrationRegisterAccount,
+  segmentAddTagToEntity,
+  segmentGetTagsForEntity,
+  segmentRemoveTagFromEntity,
+  segmentSetTagsForEntity,
   subscriptionAddDiscountToSubscription,
   subscriptionAddOnAddSubscriptionAddOn,
   subscriptionAddOnAddSubscriptionAddOnPreview,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outseta/api-client",
-  "version": "0.3.38",
+  "version": "0.3.40",
   "description": "Generated API client for the Outseta REST API",
   "license": "MIT",
   "repository": {

package/src/generated/attribute/attribute.ts

@@ -40,13 +40,18 @@ type NonReadonly<T> = [T] extends [UnionToIntersection<T>] ? {
 
 
 /**
- * Each tag applies to a single entity type. Pass entityType=Case to retrieve the tags
-that can be put on support tickets.
+ * Each tag applies to a single entity type. Pass entityType to retrieve the tags for one
+of them, for example entityType=Article for knowledge base article tags.
             
-How a tag goes onto a record depends on the entity type. A support ticket holds its
-tags in its own CaseTags collection, so you add and remove ticket tags with
-PUT /support/cases/{caseUid}. Other entity types store their tags differently. This
-documentation covers ticket tags only.
+How a tag goes onto a record depends on the entity type. Articles, broadcasts and
+segments each take tags on a tags sub-resource of the record:
+            
+- POST /support/articles/{entityUid}/tags and PUT, GET, DELETE on the same path
+- POST /email/campaigns/broadcasts/{entityUid}/tags and the same for the rest
+- POST /crm/segments/{entityUid}/tags and the same for the rest
+            
+A support ticket is the exception. It holds its tags in its own CaseTags collection, so
+you add and remove ticket tags with PUT /support/cases/{caseUid}.
             
 Name is unique within an entity type. SystemName and SystemDescription identify a
 built-in tag (for example Priority.Urgent) and are set by Outseta.
@@ -99,8 +104,9 @@ export const tagGetAllTags = async (params?: TagGetAllTagsParams, options?: Requ
 
 
 /**
- * Name and EntityType are required. Use EntityType 4 (Case) for a tag that goes on
-support tickets. TagColor sets the color the tag shows in.
+ * Name and EntityType are required. EntityType fixes what the tag can go on: 4 (Case) for
+support tickets, 13 (Article) for knowledge base articles, 12 (Broadcast) for broadcast
+emails, 11 (Segment) for segments. TagColor sets the color the tag shows in.
             
 Name must be unique within an entity type. If the name already exists for that
 entity type, the existing tag is returned instead of a duplicate, and its color is
@@ -260,6 +266,9 @@ export const tagUpdateTag = async (tagUid: string | null,
 /**
  * The tag is also taken off every record that carries it. For a Case tag, it is
 removed from all support tickets that have it.
+            
+An Article tag that the knowledge base version filter names cannot be deleted. Take it
+out of the version filter first, then delete it.
  * @summary Delete a tag.
  */
 export type tagDeleteTagResponse200 = {

package/src/generated/crm/crm.ts

@@ -23,7 +23,11 @@ import type {
   PersonGetAllPeopleParams,
   PersonRequestMagicLinkBody,
   PersonSetTemporaryPasswordBody,
-  PersonUpdatePersonBody
+  PersonUpdatePersonBody,
+  SegmentAddTagToEntityBody,
+  SegmentGetTagsForEntity200,
+  SegmentGetTagsForEntityParams,
+  SegmentSetTagsForEntityBody
 } from '.././models';
 
 import { customFetch } from '../../client';
@@ -353,6 +357,242 @@ export const registrationRegisterAccount = async (account: NonReadonly<Account>,
 );}
 
 
+/**
+ * Send the uids of the tags to add. Tags that the record already carries stay on it, and
+naming one of them again changes nothing, so the same request is safe to repeat. To
+replace the whole set instead, use PUT on this same path.
+            
+A tag belongs to one entity type, so use tags whose EntityType matches this record.
+List them with GET /attribute/tags. A uid in the list that names no tag is skipped.
+ * @summary Add tags to a record.
+ */
+export type segmentAddTagToEntityResponse200 = {
+  data: Blob
+  status: 200
+}
+
+export type segmentAddTagToEntityResponse400 = {
+  data: void
+  status: 400
+}
+
+export type segmentAddTagToEntityResponse401 = {
+  data: void
+  status: 401
+}
+
+export type segmentAddTagToEntityResponse404 = {
+  data: void
+  status: 404
+}
+    
+export type segmentAddTagToEntityResponseSuccess = (segmentAddTagToEntityResponse200) & {
+  headers: Headers;
+};
+export type segmentAddTagToEntityResponseError = (segmentAddTagToEntityResponse400 | segmentAddTagToEntityResponse401 | segmentAddTagToEntityResponse404) & {
+  headers: Headers;
+};
+
+export type segmentAddTagToEntityResponse = (segmentAddTagToEntityResponseSuccess | segmentAddTagToEntityResponseError)
+
+export const getSegmentAddTagToEntityUrl = (entityUid: string | null,) => {
+
+
+  
+
+  return `/api/v1/crm/segments/${entityUid}/tags`
+}
+
+export const segmentAddTagToEntity = async (entityUid: string | null,
+    segmentAddTagToEntityBody: SegmentAddTagToEntityBody, options?: RequestInit): Promise<segmentAddTagToEntityResponse> => {
+  
+  return customFetch<segmentAddTagToEntityResponse>(getSegmentAddTagToEntityUrl(entityUid),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      segmentAddTagToEntityBody,)
+  }
+);}
+
+
+/**
+ * Returns the tags themselves, not the links that hold them. The same tags are also
+available on the record: ask for them with the fields parameter, for example
+fields=Uid,Tags.Uid,Tags.Name,Tags.TagColor. Tags cost an extra query, so the record
+leaves them out unless fields names Tags or is a plain wildcard.
+ * @summary Retrieve the tags on a record.
+ */
+export type segmentGetTagsForEntityResponse200 = {
+  data: SegmentGetTagsForEntity200
+  status: 200
+}
+
+export type segmentGetTagsForEntityResponse400 = {
+  data: void
+  status: 400
+}
+
+export type segmentGetTagsForEntityResponse401 = {
+  data: void
+  status: 401
+}
+    
+export type segmentGetTagsForEntityResponseSuccess = (segmentGetTagsForEntityResponse200) & {
+  headers: Headers;
+};
+export type segmentGetTagsForEntityResponseError = (segmentGetTagsForEntityResponse400 | segmentGetTagsForEntityResponse401) & {
+  headers: Headers;
+};
+
+export type segmentGetTagsForEntityResponse = (segmentGetTagsForEntityResponseSuccess | segmentGetTagsForEntityResponseError)
+
+export const getSegmentGetTagsForEntityUrl = (entityUid: string | null,
+    params?: SegmentGetTagsForEntityParams,) => {
+  const normalizedParams = new URLSearchParams();
+
+  Object.entries(params || {}).forEach(([key, value]) => {
+    
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? 'null' : value.toString())
+    }
+  });
+
+  const stringifiedParams = normalizedParams.toString();
+
+  return stringifiedParams.length > 0 ? `/api/v1/crm/segments/${entityUid}/tags?${stringifiedParams}` : `/api/v1/crm/segments/${entityUid}/tags`
+}
+
+export const segmentGetTagsForEntity = async (entityUid: string | null,
+    params?: SegmentGetTagsForEntityParams, options?: RequestInit): Promise<segmentGetTagsForEntityResponse> => {
+  
+  return customFetch<segmentGetTagsForEntityResponse>(getSegmentGetTagsForEntityUrl(entityUid,params),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+/**
+ * Send the full set of tags the record must end with. A tag that the list leaves out is
+taken off the record, and one that the list names is added. Send an empty list to take
+every tag off. To add tags without disturbing the others, use POST on this same path.
+            
+A tag belongs to one entity type, so use tags whose EntityType matches this record.
+List them with GET /attribute/tags. A uid in the list that names no tag is skipped.
+ * @summary Replace the tags on a record.
+ */
+export type segmentSetTagsForEntityResponse200 = {
+  data: Blob
+  status: 200
+}
+
+export type segmentSetTagsForEntityResponse400 = {
+  data: void
+  status: 400
+}
+
+export type segmentSetTagsForEntityResponse401 = {
+  data: void
+  status: 401
+}
+
+export type segmentSetTagsForEntityResponse404 = {
+  data: void
+  status: 404
+}
+    
+export type segmentSetTagsForEntityResponseSuccess = (segmentSetTagsForEntityResponse200) & {
+  headers: Headers;
+};
+export type segmentSetTagsForEntityResponseError = (segmentSetTagsForEntityResponse400 | segmentSetTagsForEntityResponse401 | segmentSetTagsForEntityResponse404) & {
+  headers: Headers;
+};
+
+export type segmentSetTagsForEntityResponse = (segmentSetTagsForEntityResponseSuccess | segmentSetTagsForEntityResponseError)
+
+export const getSegmentSetTagsForEntityUrl = (entityUid: string | null,) => {
+
+
+  
+
+  return `/api/v1/crm/segments/${entityUid}/tags`
+}
+
+export const segmentSetTagsForEntity = async (entityUid: string | null,
+    segmentSetTagsForEntityBody: SegmentSetTagsForEntityBody, options?: RequestInit): Promise<segmentSetTagsForEntityResponse> => {
+  
+  return customFetch<segmentSetTagsForEntityResponse>(getSegmentSetTagsForEntityUrl(entityUid),
+  {      
+    ...options,
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      segmentSetTagsForEntityBody,)
+  }
+);}
+
+
+/**
+ * The tag itself is kept and stays available for other records. If the record does not
+carry the tag, nothing changes and the call still succeeds.
+ * @summary Remove one tag from a record.
+ */
+export type segmentRemoveTagFromEntityResponse200 = {
+  data: Blob
+  status: 200
+}
+
+export type segmentRemoveTagFromEntityResponse400 = {
+  data: void
+  status: 400
+}
+
+export type segmentRemoveTagFromEntityResponse401 = {
+  data: void
+  status: 401
+}
+
+export type segmentRemoveTagFromEntityResponse404 = {
+  data: void
+  status: 404
+}
+    
+export type segmentRemoveTagFromEntityResponseSuccess = (segmentRemoveTagFromEntityResponse200) & {
+  headers: Headers;
+};
+export type segmentRemoveTagFromEntityResponseError = (segmentRemoveTagFromEntityResponse400 | segmentRemoveTagFromEntityResponse401 | segmentRemoveTagFromEntityResponse404) & {
+  headers: Headers;
+};
+
+export type segmentRemoveTagFromEntityResponse = (segmentRemoveTagFromEntityResponseSuccess | segmentRemoveTagFromEntityResponseError)
+
+export const getSegmentRemoveTagFromEntityUrl = (entityUid: string | null,
+    tagUid: string | null,) => {
+
+
+  
+
+  return `/api/v1/crm/segments/${entityUid}/tags/${tagUid}`
+}
+
+export const segmentRemoveTagFromEntity = async (entityUid: string | null,
+    tagUid: string | null, options?: RequestInit): Promise<segmentRemoveTagFromEntityResponse> => {
+  
+  return customFetch<segmentRemoveTagFromEntityResponse>(getSegmentRemoveTagFromEntityUrl(entityUid,tagUid),
+  {      
+    ...options,
+    method: 'DELETE'
+    
+    
+  }
+);}
+
+
 /**
  * Optionally filtered by segment (segmentUid) or search query (q).
  * @summary Retrieve all accounts.

package/src/generated/email/email.ts

@@ -2,9 +2,13 @@
 import type {
   BroadcastCampaign,
   CampaignAddBroadcastEmailBody,
+  CampaignAddTagToEntityBody,
   CampaignGetAllBroadcastEmails200,
   CampaignGetAllBroadcastEmailsParams,
+  CampaignGetTagsForEntity200,
+  CampaignGetTagsForEntityParams,
   CampaignSendTestCampaignEmailBody,
+  CampaignSetTagsForEntityBody,
   CampaignUpdateBroadcastEmailBody,
   DripCampaign,
   DripCampaignAddDripCampaignBody,
@@ -655,6 +659,15 @@ omitted it is derived automatically, so callers (including LLM tools) do not nee
 understand it. Use Message.PreviewText for inbox preview text rather than an in-body
 preheader.
             
+The shape of the Body markup decides how editable the broadcast is in the app. Prose
+(headings, paragraphs, lists, links, emphasis, images, inline spans) goes into a text
+block, which the author edits on the editor canvas with the formatting toolbar and the
+merge-tag menu. Structural markup (tables, an embedded style block, document
+scaffolding) goes into an HTML block instead, because only that block renders such
+markup verbatim, and it is edited as raw HTML. Send prose when the email must stay easy
+to edit visually. The first save in the editor also replaces Body with the editor's
+export of the design, so this choice decides the markup that is sent from then on.
+            
 When Body is a content fragment with no Design, it is composed into the account's API
 email layout — a branded header and footer that includes the unsubscribe and
 manage-subscriptions links — and the composed result is what is sent and opened in the
@@ -1038,6 +1051,242 @@ export const campaignSendTestCampaignEmail = async (campaignSendTestCampaignEmai
 );}
 
 
+/**
+ * Send the uids of the tags to add. Tags that the record already carries stay on it, and
+naming one of them again changes nothing, so the same request is safe to repeat. To
+replace the whole set instead, use PUT on this same path.
+            
+A tag belongs to one entity type, so use tags whose EntityType matches this record.
+List them with GET /attribute/tags. A uid in the list that names no tag is skipped.
+ * @summary Add tags to a record.
+ */
+export type campaignAddTagToEntityResponse200 = {
+  data: Blob
+  status: 200
+}
+
+export type campaignAddTagToEntityResponse400 = {
+  data: void
+  status: 400
+}
+
+export type campaignAddTagToEntityResponse401 = {
+  data: void
+  status: 401
+}
+
+export type campaignAddTagToEntityResponse404 = {
+  data: void
+  status: 404
+}
+    
+export type campaignAddTagToEntityResponseSuccess = (campaignAddTagToEntityResponse200) & {
+  headers: Headers;
+};
+export type campaignAddTagToEntityResponseError = (campaignAddTagToEntityResponse400 | campaignAddTagToEntityResponse401 | campaignAddTagToEntityResponse404) & {
+  headers: Headers;
+};
+
+export type campaignAddTagToEntityResponse = (campaignAddTagToEntityResponseSuccess | campaignAddTagToEntityResponseError)
+
+export const getCampaignAddTagToEntityUrl = (entityUid: string | null,) => {
+
+
+  
+
+  return `/api/v1/email/campaigns/broadcasts/${entityUid}/tags`
+}
+
+export const campaignAddTagToEntity = async (entityUid: string | null,
+    campaignAddTagToEntityBody: CampaignAddTagToEntityBody, options?: RequestInit): Promise<campaignAddTagToEntityResponse> => {
+  
+  return customFetch<campaignAddTagToEntityResponse>(getCampaignAddTagToEntityUrl(entityUid),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      campaignAddTagToEntityBody,)
+  }
+);}
+
+
+/**
+ * Returns the tags themselves, not the links that hold them. The same tags are also
+available on the record: ask for them with the fields parameter, for example
+fields=Uid,Tags.Uid,Tags.Name,Tags.TagColor. Tags cost an extra query, so the record
+leaves them out unless fields names Tags or is a plain wildcard.
+ * @summary Retrieve the tags on a record.
+ */
+export type campaignGetTagsForEntityResponse200 = {
+  data: CampaignGetTagsForEntity200
+  status: 200
+}
+
+export type campaignGetTagsForEntityResponse400 = {
+  data: void
+  status: 400
+}
+
+export type campaignGetTagsForEntityResponse401 = {
+  data: void
+  status: 401
+}
+    
+export type campaignGetTagsForEntityResponseSuccess = (campaignGetTagsForEntityResponse200) & {
+  headers: Headers;
+};
+export type campaignGetTagsForEntityResponseError = (campaignGetTagsForEntityResponse400 | campaignGetTagsForEntityResponse401) & {
+  headers: Headers;
+};
+
+export type campaignGetTagsForEntityResponse = (campaignGetTagsForEntityResponseSuccess | campaignGetTagsForEntityResponseError)
+
+export const getCampaignGetTagsForEntityUrl = (entityUid: string | null,
+    params?: CampaignGetTagsForEntityParams,) => {
+  const normalizedParams = new URLSearchParams();
+
+  Object.entries(params || {}).forEach(([key, value]) => {
+    
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? 'null' : value.toString())
+    }
+  });
+
+  const stringifiedParams = normalizedParams.toString();
+
+  return stringifiedParams.length > 0 ? `/api/v1/email/campaigns/broadcasts/${entityUid}/tags?${stringifiedParams}` : `/api/v1/email/campaigns/broadcasts/${entityUid}/tags`
+}
+
+export const campaignGetTagsForEntity = async (entityUid: string | null,
+    params?: CampaignGetTagsForEntityParams, options?: RequestInit): Promise<campaignGetTagsForEntityResponse> => {
+  
+  return customFetch<campaignGetTagsForEntityResponse>(getCampaignGetTagsForEntityUrl(entityUid,params),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+/**
+ * Send the full set of tags the record must end with. A tag that the list leaves out is
+taken off the record, and one that the list names is added. Send an empty list to take
+every tag off. To add tags without disturbing the others, use POST on this same path.
+            
+A tag belongs to one entity type, so use tags whose EntityType matches this record.
+List them with GET /attribute/tags. A uid in the list that names no tag is skipped.
+ * @summary Replace the tags on a record.
+ */
+export type campaignSetTagsForEntityResponse200 = {
+  data: Blob
+  status: 200
+}
+
+export type campaignSetTagsForEntityResponse400 = {
+  data: void
+  status: 400
+}
+
+export type campaignSetTagsForEntityResponse401 = {
+  data: void
+  status: 401
+}
+
+export type campaignSetTagsForEntityResponse404 = {
+  data: void
+  status: 404
+}
+    
+export type campaignSetTagsForEntityResponseSuccess = (campaignSetTagsForEntityResponse200) & {
+  headers: Headers;
+};
+export type campaignSetTagsForEntityResponseError = (campaignSetTagsForEntityResponse400 | campaignSetTagsForEntityResponse401 | campaignSetTagsForEntityResponse404) & {
+  headers: Headers;
+};
+
+export type campaignSetTagsForEntityResponse = (campaignSetTagsForEntityResponseSuccess | campaignSetTagsForEntityResponseError)
+
+export const getCampaignSetTagsForEntityUrl = (entityUid: string | null,) => {
+
+
+  
+
+  return `/api/v1/email/campaigns/broadcasts/${entityUid}/tags`
+}
+
+export const campaignSetTagsForEntity = async (entityUid: string | null,
+    campaignSetTagsForEntityBody: CampaignSetTagsForEntityBody, options?: RequestInit): Promise<campaignSetTagsForEntityResponse> => {
+  
+  return customFetch<campaignSetTagsForEntityResponse>(getCampaignSetTagsForEntityUrl(entityUid),
+  {      
+    ...options,
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      campaignSetTagsForEntityBody,)
+  }
+);}
+
+
+/**
+ * The tag itself is kept and stays available for other records. If the record does not
+carry the tag, nothing changes and the call still succeeds.
+ * @summary Remove one tag from a record.
+ */
+export type campaignRemoveTagFromEntityResponse200 = {
+  data: Blob
+  status: 200
+}
+
+export type campaignRemoveTagFromEntityResponse400 = {
+  data: void
+  status: 400
+}
+
+export type campaignRemoveTagFromEntityResponse401 = {
+  data: void
+  status: 401
+}
+
+export type campaignRemoveTagFromEntityResponse404 = {
+  data: void
+  status: 404
+}
+    
+export type campaignRemoveTagFromEntityResponseSuccess = (campaignRemoveTagFromEntityResponse200) & {
+  headers: Headers;
+};
+export type campaignRemoveTagFromEntityResponseError = (campaignRemoveTagFromEntityResponse400 | campaignRemoveTagFromEntityResponse401 | campaignRemoveTagFromEntityResponse404) & {
+  headers: Headers;
+};
+
+export type campaignRemoveTagFromEntityResponse = (campaignRemoveTagFromEntityResponseSuccess | campaignRemoveTagFromEntityResponseError)
+
+export const getCampaignRemoveTagFromEntityUrl = (entityUid: string | null,
+    tagUid: string | null,) => {
+
+
+  
+
+  return `/api/v1/email/campaigns/broadcasts/${entityUid}/tags/${tagUid}`
+}
+
+export const campaignRemoveTagFromEntity = async (entityUid: string | null,
+    tagUid: string | null, options?: RequestInit): Promise<campaignRemoveTagFromEntityResponse> => {
+  
+  return customFetch<campaignRemoveTagFromEntityResponse>(getCampaignRemoveTagFromEntityUrl(entityUid,tagUid),
+  {      
+    ...options,
+    method: 'DELETE'
+    
+    
+  }
+);}
+
+
 /**
  * @summary Retrieve all email lists.
  */

package/src/generated/models/articleAddTagToEntityBody.ts

@@ -0,0 +1,7 @@
+// @ts-nocheck
+import type { TagUidList } from './tagUidList';
+
+/**
+ * @nullable
+ */
+export type ArticleAddTagToEntityBody = TagUidList | null;

package/src/generated/models/articleAllOf.ts

@@ -1,6 +1,7 @@
 // @ts-nocheck
 import type { SupportArticleStatus } from './supportArticleStatus';
 import type { ArticleAllOfCategory } from './articleAllOfCategory';
+import type { Tag } from './tag';
 
 export type ArticleAllOf = {
   Weight?: number;
@@ -23,4 +24,6 @@ export type ArticleAllOf = {
    * @nullable
    */
   Keywords?: string | null;
+  /** @nullable */
+  Tags?: Tag[] | null;
 };

package/src/generated/models/articleGetAllArticlesParams.ts

@@ -8,6 +8,14 @@ export type ArticleGetAllArticlesParams = {
  * @nullable
  */
 q?: string | null;
+/**
+ * Keep only the records that carry one of these tags. Separate several tag uids with commas. The value none keeps the records that carry no tag at all.
+ */
+tagUid?: string;
+/**
+ * Keep only the records that carry none of these tags. Separate several tag uids with commas. Combined with tagUid, the two widen the result instead of narrowing it: a record is kept when it matches either one.
+ */
+withoutTagUid?: string;
 /**
  * Requested page size. The server caps it at 100, or 25 when requested fields expand child objects or require additional queries; metadata.limit reports the applied value. Use offset=1 for the second page.
  */

package/src/generated/models/articleGetTagsForEntity200.ts

@@ -0,0 +1,8 @@
+// @ts-nocheck
+import type { CollectionMetadata } from './collectionMetadata';
+import type { Tag } from './tag';
+
+export type ArticleGetTagsForEntity200 = {
+  metadata?: CollectionMetadata;
+  items?: Tag[];
+};

package/src/generated/models/articleGetTagsForEntityParams.ts

@@ -0,0 +1,14 @@
+// @ts-nocheck
+import type { LimitParameter } from './limitParameter';
+import type { OffsetParameter } from './offsetParameter';
+
+export type ArticleGetTagsForEntityParams = {
+/**
+ * Requested page size. The server caps it at 100, or 25 when requested fields expand child objects or require additional queries; metadata.limit reports the applied value. Use offset=1 for the second page.
+ */
+limit?: LimitParameter;
+/**
+ * Zero-based page number, not a record offset. With limit=50, the second page is offset=1; offset=50 is page index 50 (records 2501-2550).
+ */
+offset?: OffsetParameter;
+};

package/src/generated/models/articleSetTagsForEntityBody.ts

@@ -0,0 +1,7 @@
+// @ts-nocheck
+import type { TagUidList } from './tagUidList';
+
+/**
+ * @nullable
+ */
+export type ArticleSetTagsForEntityBody = TagUidList | null;

package/src/generated/models/campaignAddTagToEntityBody.ts

@@ -0,0 +1,7 @@
+// @ts-nocheck
+import type { TagUidList } from './tagUidList';
+
+/**
+ * @nullable
+ */
+export type CampaignAddTagToEntityBody = TagUidList | null;

package/src/generated/models/campaignGetAllBroadcastEmailsParams.ts

@@ -3,6 +3,14 @@ import type { LimitParameter } from './limitParameter';
 import type { OffsetParameter } from './offsetParameter';
 
 export type CampaignGetAllBroadcastEmailsParams = {
+/**
+ * Keep only the records that carry one of these tags. Separate several tag uids with commas. The value none keeps the records that carry no tag at all.
+ */
+tagUid?: string;
+/**
+ * Keep only the records that carry none of these tags. Separate several tag uids with commas. Combined with tagUid, the two widen the result instead of narrowing it: a record is kept when it matches either one.
+ */
+withoutTagUid?: string;
 /**
  * Requested page size. The server caps it at 100, or 25 when requested fields expand child objects or require additional queries; metadata.limit reports the applied value. Use offset=1 for the second page.
  */

package/src/generated/models/campaignGetTagsForEntity200.ts

@@ -0,0 +1,8 @@
+// @ts-nocheck
+import type { CollectionMetadata } from './collectionMetadata';
+import type { Tag } from './tag';
+
+export type CampaignGetTagsForEntity200 = {
+  metadata?: CollectionMetadata;
+  items?: Tag[];
+};

package/src/generated/models/campaignGetTagsForEntityParams.ts

@@ -0,0 +1,14 @@
+// @ts-nocheck
+import type { LimitParameter } from './limitParameter';
+import type { OffsetParameter } from './offsetParameter';
+
+export type CampaignGetTagsForEntityParams = {
+/**
+ * Requested page size. The server caps it at 100, or 25 when requested fields expand child objects or require additional queries; metadata.limit reports the applied value. Use offset=1 for the second page.
+ */
+limit?: LimitParameter;
+/**
+ * Zero-based page number, not a record offset. With limit=50, the second page is offset=1; offset=50 is page index 50 (records 2501-2550).
+ */
+offset?: OffsetParameter;
+};

package/src/generated/models/campaignSetTagsForEntityBody.ts

@@ -0,0 +1,7 @@
+// @ts-nocheck
+import type { TagUidList } from './tagUidList';
+
+/**
+ * @nullable
+ */
+export type CampaignSetTagsForEntityBody = TagUidList | null;

package/src/generated/models/entityType.ts

@@ -1,7 +1,7 @@
 // @ts-nocheck
 
 /**
- * `0` - None, `1` - Account, `2` - Person, `3` - Deal, `4` - Case, `5` - Invoice, `6` - EmailLog, `7` - Plan, `8` - DiscountCoupon, `9` - AddOn, `10` - Task, `11` - Segment, `12` - Broadcast
+ * `0` - None, `1` - Account, `2` - Person, `3` - Deal, `4` - Case, `5` - Invoice, `6` - EmailLog, `7` - Plan, `8` - DiscountCoupon, `9` - AddOn, `10` - Task, `11` - Segment, `12` - Broadcast, `13` - Article
  */
 export type EntityType = typeof EntityType[keyof typeof EntityType];
 
@@ -21,4 +21,5 @@ export const EntityType = {
   Task: 10,
   Segment: 11,
   Broadcast: 12,
+  Article: 13,
 } as const;

package/src/generated/models/index.ts

@@ -227,10 +227,14 @@ export * from './apiKeyAllOfQcount';
 export * from './apiKeyType';
 export * from './article';
 export * from './articleAddArticleBody';
+export * from './articleAddTagToEntityBody';
 export * from './articleAllOf';
 export * from './articleAllOfCategory';
 export * from './articleGetAllArticles200';
 export * from './articleGetAllArticlesParams';
+export * from './articleGetTagsForEntity200';
+export * from './articleGetTagsForEntityParams';
+export * from './articleSetTagsForEntityBody';
 export * from './authGetTokenParams';
 export * from './authMagicLinkTokenParams';
 export * from './authResendTwoFactorParams';
@@ -252,10 +256,14 @@ export * from './broadcastCampaignAllOfMessage';
 export * from './broadcastCampaignStatus';
 export * from './campaign';
 export * from './campaignAddBroadcastEmailBody';
+export * from './campaignAddTagToEntityBody';
 export * from './campaignAllOf';
 export * from './campaignGetAllBroadcastEmails200';
 export * from './campaignGetAllBroadcastEmailsParams';
+export * from './campaignGetTagsForEntity200';
+export * from './campaignGetTagsForEntityParams';
 export * from './campaignSendTestCampaignEmailBody';
+export * from './campaignSetTagsForEntityBody';
 export * from './campaignType';
 export * from './campaignUpdateBroadcastEmailBody';
 export * from './cancelationStatus';
@@ -559,11 +567,15 @@ export * from './qcountStatus';
 export * from './registrationField';
 export * from './resendEmailsRequest';
 export * from './segment';
+export * from './segmentAddTagToEntityBody';
 export * from './segmentAllOf';
+export * from './segmentGetTagsForEntity200';
+export * from './segmentGetTagsForEntityParams';
 export * from './segmentPerson';
 export * from './segmentPersonAllOf';
 export * from './segmentPersonAllOfPerson';
 export * from './segmentPersonAllOfSegment';
+export * from './segmentSetTagsForEntityBody';
 export * from './sendGridDomainAuthentication';
 export * from './sendGridDomainAuthenticationAllOf';
 export * from './sendTemplateEmailRequest';

package/src/generated/models/segmentAddTagToEntityBody.ts

@@ -0,0 +1,7 @@
+// @ts-nocheck
+import type { TagUidList } from './tagUidList';
+
+/**
+ * @nullable
+ */
+export type SegmentAddTagToEntityBody = TagUidList | null;

package/src/generated/models/segmentGetTagsForEntity200.ts

@@ -0,0 +1,8 @@
+// @ts-nocheck
+import type { CollectionMetadata } from './collectionMetadata';
+import type { Tag } from './tag';
+
+export type SegmentGetTagsForEntity200 = {
+  metadata?: CollectionMetadata;
+  items?: Tag[];
+};

package/src/generated/models/segmentGetTagsForEntityParams.ts

@@ -0,0 +1,14 @@
+// @ts-nocheck
+import type { LimitParameter } from './limitParameter';
+import type { OffsetParameter } from './offsetParameter';
+
+export type SegmentGetTagsForEntityParams = {
+/**
+ * Requested page size. The server caps it at 100, or 25 when requested fields expand child objects or require additional queries; metadata.limit reports the applied value. Use offset=1 for the second page.
+ */
+limit?: LimitParameter;
+/**
+ * Zero-based page number, not a record offset. With limit=50, the second page is offset=1; offset=50 is page index 50 (records 2501-2550).
+ */
+offset?: OffsetParameter;
+};

package/src/generated/models/segmentSetTagsForEntityBody.ts

@@ -0,0 +1,7 @@
+// @ts-nocheck
+import type { TagUidList } from './tagUidList';
+
+/**
+ * @nullable
+ */
+export type SegmentSetTagsForEntityBody = TagUidList | null;

package/src/generated/models/supportSettingsAllOf.ts

@@ -23,6 +23,8 @@ export type SupportSettingsAllOf = {
   /** @nullable */
   KnowledgeBaseFooterLinkJSON?: string | null;
   /** @nullable */
+  KnowledgeBaseFilterJSON?: string | null;
+  /** @nullable */
   OfficeHoursJSON?: string | null;
   /** @nullable */
   EmailNotificationForNewTickets?: string | null;

package/src/generated/support/support.ts

@@ -2,8 +2,12 @@
 import type {
   Article,
   ArticleAddArticleBody,
+  ArticleAddTagToEntityBody,
   ArticleGetAllArticles200,
   ArticleGetAllArticlesParams,
+  ArticleGetTagsForEntity200,
+  ArticleGetTagsForEntityParams,
+  ArticleSetTagsForEntityBody,
   Case,
   CaseAddCaseBody,
   CaseAddCaseParams,
@@ -514,6 +518,242 @@ export const articleGetArticle = async (articleUid: string | null, options?: Req
 );}
 
 
+/**
+ * Send the uids of the tags to add. Tags that the record already carries stay on it, and
+naming one of them again changes nothing, so the same request is safe to repeat. To
+replace the whole set instead, use PUT on this same path.
+            
+A tag belongs to one entity type, so use tags whose EntityType matches this record.
+List them with GET /attribute/tags. A uid in the list that names no tag is skipped.
+ * @summary Add tags to a record.
+ */
+export type articleAddTagToEntityResponse200 = {
+  data: Blob
+  status: 200
+}
+
+export type articleAddTagToEntityResponse400 = {
+  data: void
+  status: 400
+}
+
+export type articleAddTagToEntityResponse401 = {
+  data: void
+  status: 401
+}
+
+export type articleAddTagToEntityResponse404 = {
+  data: void
+  status: 404
+}
+    
+export type articleAddTagToEntityResponseSuccess = (articleAddTagToEntityResponse200) & {
+  headers: Headers;
+};
+export type articleAddTagToEntityResponseError = (articleAddTagToEntityResponse400 | articleAddTagToEntityResponse401 | articleAddTagToEntityResponse404) & {
+  headers: Headers;
+};
+
+export type articleAddTagToEntityResponse = (articleAddTagToEntityResponseSuccess | articleAddTagToEntityResponseError)
+
+export const getArticleAddTagToEntityUrl = (entityUid: string | null,) => {
+
+
+  
+
+  return `/api/v1/support/articles/${entityUid}/tags`
+}
+
+export const articleAddTagToEntity = async (entityUid: string | null,
+    articleAddTagToEntityBody: ArticleAddTagToEntityBody, options?: RequestInit): Promise<articleAddTagToEntityResponse> => {
+  
+  return customFetch<articleAddTagToEntityResponse>(getArticleAddTagToEntityUrl(entityUid),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      articleAddTagToEntityBody,)
+  }
+);}
+
+
+/**
+ * Returns the tags themselves, not the links that hold them. The same tags are also
+available on the record: ask for them with the fields parameter, for example
+fields=Uid,Tags.Uid,Tags.Name,Tags.TagColor. Tags cost an extra query, so the record
+leaves them out unless fields names Tags or is a plain wildcard.
+ * @summary Retrieve the tags on a record.
+ */
+export type articleGetTagsForEntityResponse200 = {
+  data: ArticleGetTagsForEntity200
+  status: 200
+}
+
+export type articleGetTagsForEntityResponse400 = {
+  data: void
+  status: 400
+}
+
+export type articleGetTagsForEntityResponse401 = {
+  data: void
+  status: 401
+}
+    
+export type articleGetTagsForEntityResponseSuccess = (articleGetTagsForEntityResponse200) & {
+  headers: Headers;
+};
+export type articleGetTagsForEntityResponseError = (articleGetTagsForEntityResponse400 | articleGetTagsForEntityResponse401) & {
+  headers: Headers;
+};
+
+export type articleGetTagsForEntityResponse = (articleGetTagsForEntityResponseSuccess | articleGetTagsForEntityResponseError)
+
+export const getArticleGetTagsForEntityUrl = (entityUid: string | null,
+    params?: ArticleGetTagsForEntityParams,) => {
+  const normalizedParams = new URLSearchParams();
+
+  Object.entries(params || {}).forEach(([key, value]) => {
+    
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? 'null' : value.toString())
+    }
+  });
+
+  const stringifiedParams = normalizedParams.toString();
+
+  return stringifiedParams.length > 0 ? `/api/v1/support/articles/${entityUid}/tags?${stringifiedParams}` : `/api/v1/support/articles/${entityUid}/tags`
+}
+
+export const articleGetTagsForEntity = async (entityUid: string | null,
+    params?: ArticleGetTagsForEntityParams, options?: RequestInit): Promise<articleGetTagsForEntityResponse> => {
+  
+  return customFetch<articleGetTagsForEntityResponse>(getArticleGetTagsForEntityUrl(entityUid,params),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+/**
+ * Send the full set of tags the record must end with. A tag that the list leaves out is
+taken off the record, and one that the list names is added. Send an empty list to take
+every tag off. To add tags without disturbing the others, use POST on this same path.
+            
+A tag belongs to one entity type, so use tags whose EntityType matches this record.
+List them with GET /attribute/tags. A uid in the list that names no tag is skipped.
+ * @summary Replace the tags on a record.
+ */
+export type articleSetTagsForEntityResponse200 = {
+  data: Blob
+  status: 200
+}
+
+export type articleSetTagsForEntityResponse400 = {
+  data: void
+  status: 400
+}
+
+export type articleSetTagsForEntityResponse401 = {
+  data: void
+  status: 401
+}
+
+export type articleSetTagsForEntityResponse404 = {
+  data: void
+  status: 404
+}
+    
+export type articleSetTagsForEntityResponseSuccess = (articleSetTagsForEntityResponse200) & {
+  headers: Headers;
+};
+export type articleSetTagsForEntityResponseError = (articleSetTagsForEntityResponse400 | articleSetTagsForEntityResponse401 | articleSetTagsForEntityResponse404) & {
+  headers: Headers;
+};
+
+export type articleSetTagsForEntityResponse = (articleSetTagsForEntityResponseSuccess | articleSetTagsForEntityResponseError)
+
+export const getArticleSetTagsForEntityUrl = (entityUid: string | null,) => {
+
+
+  
+
+  return `/api/v1/support/articles/${entityUid}/tags`
+}
+
+export const articleSetTagsForEntity = async (entityUid: string | null,
+    articleSetTagsForEntityBody: ArticleSetTagsForEntityBody, options?: RequestInit): Promise<articleSetTagsForEntityResponse> => {
+  
+  return customFetch<articleSetTagsForEntityResponse>(getArticleSetTagsForEntityUrl(entityUid),
+  {      
+    ...options,
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      articleSetTagsForEntityBody,)
+  }
+);}
+
+
+/**
+ * The tag itself is kept and stays available for other records. If the record does not
+carry the tag, nothing changes and the call still succeeds.
+ * @summary Remove one tag from a record.
+ */
+export type articleRemoveTagFromEntityResponse200 = {
+  data: Blob
+  status: 200
+}
+
+export type articleRemoveTagFromEntityResponse400 = {
+  data: void
+  status: 400
+}
+
+export type articleRemoveTagFromEntityResponse401 = {
+  data: void
+  status: 401
+}
+
+export type articleRemoveTagFromEntityResponse404 = {
+  data: void
+  status: 404
+}
+    
+export type articleRemoveTagFromEntityResponseSuccess = (articleRemoveTagFromEntityResponse200) & {
+  headers: Headers;
+};
+export type articleRemoveTagFromEntityResponseError = (articleRemoveTagFromEntityResponse400 | articleRemoveTagFromEntityResponse401 | articleRemoveTagFromEntityResponse404) & {
+  headers: Headers;
+};
+
+export type articleRemoveTagFromEntityResponse = (articleRemoveTagFromEntityResponseSuccess | articleRemoveTagFromEntityResponseError)
+
+export const getArticleRemoveTagFromEntityUrl = (entityUid: string | null,
+    tagUid: string | null,) => {
+
+
+  
+
+  return `/api/v1/support/articles/${entityUid}/tags/${tagUid}`
+}
+
+export const articleRemoveTagFromEntity = async (entityUid: string | null,
+    tagUid: string | null, options?: RequestInit): Promise<articleRemoveTagFromEntityResponse> => {
+  
+  return customFetch<articleRemoveTagFromEntityResponse>(getArticleRemoveTagFromEntityUrl(entityUid,tagUid),
+  {      
+    ...options,
+    method: 'DELETE'
+    
+    
+  }
+);}
+
+
 /**
  * @summary Retrieve all knowledge base categories.
  */