@outseta/react 0.4.32 → 0.4.34

package/src/generated/outsetaAPI.schemas.ts

@@ -101,7 +101,7 @@ export const TagColor = {
 } as const;
 
 /**
- * `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];
 
@@ -121,6 +121,7 @@ export const EntityType = {
   Task: 10,
   Segment: 11,
   Broadcast: 12,
+  Article: 13,
 } as const;
 
 export type DefinitionAllOf = {
@@ -3211,6 +3212,8 @@ export type ArticleAllOf = {
    * @nullable
    */
   Keywords?: string | null;
+  /** @nullable */
+  Tags?: Tag[] | null;
 };
 
 export type Article = AbstractQcountBean & ArticleAllOf;
@@ -3243,6 +3246,11 @@ export type CategoryAllOf = {
 
 export type Category = AbstractQcountBean & CategoryAllOf;
 
+export interface TagUidList {
+  /** @nullable */
+  TagUids?: string[] | null;
+}
+
 export type SupportSettingsAllOf = {
   /** @nullable */
   EmailAddress?: string | null;
@@ -3266,6 +3274,8 @@ export type SupportSettingsAllOf = {
   /** @nullable */
   KnowledgeBaseFooterLinkJSON?: string | null;
   /** @nullable */
+  KnowledgeBaseFilterJSON?: string | null;
+  /** @nullable */
   OfficeHoursJSON?: string | null;
   /** @nullable */
   EmailNotificationForNewTickets?: string | null;
@@ -4378,11 +4388,6 @@ export interface SendTestEmailRequest2 {
   AdditionalRecipients?: string[] | null;
 }
 
-export interface TagUidList {
-  /** @nullable */
-  TagUids?: string[] | null;
-}
-
 /**
  * @nullable
  */
@@ -9364,6 +9369,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.
  */
@@ -9384,6 +9397,32 @@ export type ArticleGetAllArticles200 = {
  */
 export type ArticleAddArticleBody = Article | null;
 
+/**
+ * @nullable
+ */
+export type ArticleAddTagToEntityBody = TagUidList | null;
+
+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;
+};
+
+export type ArticleGetTagsForEntity200 = {
+  metadata?: CollectionMetadata;
+  items?: Tag[];
+};
+
+/**
+ * @nullable
+ */
+export type ArticleSetTagsForEntityBody = TagUidList | null;
+
 export type CategoryGetAllCategoriesParams = {
 /**
  * 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.
@@ -9479,6 +9518,14 @@ export type DripCampaignUpdateDripCampaignMessageBody = DripCampaignMessage | nu
 export type DripCampaignSendTestCampaignEmailBody = SendTestEmailRequest | null;
 
 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.
  */
@@ -9509,6 +9556,32 @@ export type CampaignUpdateBroadcastEmailBody = BroadcastCampaign | null;
  */
 export type CampaignSendTestCampaignEmailBody = SendTestEmailRequest2 | null;
 
+/**
+ * @nullable
+ */
+export type CampaignAddTagToEntityBody = TagUidList | null;
+
+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;
+};
+
+export type CampaignGetTagsForEntity200 = {
+  metadata?: CollectionMetadata;
+  items?: Tag[];
+};
+
+/**
+ * @nullable
+ */
+export type CampaignSetTagsForEntityBody = TagUidList | null;
+
 export type EmailListGetAllEmailListsParams = {
 /**
  * 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.
@@ -9597,6 +9670,32 @@ export type DealAddDealBody = Deal | null;
  */
 export type DealUpdateDealBody = Deal | null;
 
+/**
+ * @nullable
+ */
+export type SegmentAddTagToEntityBody = TagUidList | null;
+
+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;
+};
+
+export type SegmentGetTagsForEntity200 = {
+  metadata?: CollectionMetadata;
+  items?: Tag[];
+};
+
+/**
+ * @nullable
+ */
+export type SegmentSetTagsForEntityBody = TagUidList | null;
+
 export type AccountGetAllAccountsParams = {
 /**
  * Accounts are filtered based on whether they are associated with the segment

package/src/generated/support/support.ts

@@ -16,8 +16,12 @@ import type {
 import type {
   Article,
   ArticleAddArticleBody,
+  ArticleAddTagToEntityBody,
   ArticleGetAllArticles200,
   ArticleGetAllArticlesParams,
+  ArticleGetTagsForEntity200,
+  ArticleGetTagsForEntityParams,
+  ArticleSetTagsForEntityBody,
   Case,
   CaseAddCaseBody,
   CaseAddCaseParams,
@@ -679,6 +683,291 @@ export function useArticleGetArticle<TData = Awaited<ReturnType<typeof articleGe
 
 
 /**
+ * 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 const articleAddTagToEntity = (
+    entityUid: string | null,
+    articleAddTagToEntityBody: ArticleAddTagToEntityBody,
+ options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
+) => {
+      
+      
+      return customFetch<Blob>(
+      {url: `/api/v1/support/articles/${entityUid}/tags`, method: 'POST',
+      headers: {'Content-Type': 'application/json', },
+      data: articleAddTagToEntityBody,
+        responseType: 'blob', signal
+    },
+      options);
+    }
+  
+
+
+export const getArticleAddTagToEntityMutationOptions = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof articleAddTagToEntity>>, TError,{entityUid: string | null;data: ArticleAddTagToEntityBody}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof articleAddTagToEntity>>, TError,{entityUid: string | null;data: ArticleAddTagToEntityBody}, TContext> => {
+
+const mutationKey = ['articleAddTagToEntity'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+      
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof articleAddTagToEntity>>, {entityUid: string | null;data: ArticleAddTagToEntityBody}> = (props) => {
+          const {entityUid,data} = props ?? {};
+
+          return  articleAddTagToEntity(entityUid,data,requestOptions)
+        }
+
+        
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type ArticleAddTagToEntityMutationResult = NonNullable<Awaited<ReturnType<typeof articleAddTagToEntity>>>
+    export type ArticleAddTagToEntityMutationBody = ArticleAddTagToEntityBody
+    export type ArticleAddTagToEntityMutationError = void
+
+    /**
+ * @summary Add tags to a record.
+ */
+export const useArticleAddTagToEntity = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof articleAddTagToEntity>>, TError,{entityUid: string | null;data: ArticleAddTagToEntityBody}, TContext>, request?: SecondParameter<typeof customFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof articleAddTagToEntity>>,
+        TError,
+        {entityUid: string | null;data: ArticleAddTagToEntityBody},
+        TContext
+      > => {
+
+      const mutationOptions = getArticleAddTagToEntityMutationOptions(options);
+
+      return useMutation(mutationOptions);
+    }
+    /**
+ * 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 const articleGetTagsForEntity = (
+    entityUid: string | null,
+    params?: ArticleGetTagsForEntityParams,
+ options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
+) => {
+      
+      
+      return customFetch<ArticleGetTagsForEntity200>(
+      {url: `/api/v1/support/articles/${entityUid}/tags`, method: 'GET',
+        params, signal
+    },
+      options);
+    }
+  
+
+
+
+export const getArticleGetTagsForEntityQueryKey = (entityUid?: string | null,
+    params?: ArticleGetTagsForEntityParams,) => {
+    return [
+    `/api/v1/support/articles/${entityUid}/tags`, ...(params ? [params]: [])
+    ] as const;
+    }
+
+    
+export const getArticleGetTagsForEntityQueryOptions = <TData = Awaited<ReturnType<typeof articleGetTagsForEntity>>, TError = void>(entityUid: string | null,
+    params?: ArticleGetTagsForEntityParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof articleGetTagsForEntity>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getArticleGetTagsForEntityQueryKey(entityUid,params);
+
+  
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof articleGetTagsForEntity>>> = ({ signal }) => articleGetTagsForEntity(entityUid,params, requestOptions, signal);
+
+      
+
+      
+
+   return  { queryKey, queryFn, enabled: !!(entityUid), ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof articleGetTagsForEntity>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type ArticleGetTagsForEntityQueryResult = NonNullable<Awaited<ReturnType<typeof articleGetTagsForEntity>>>
+export type ArticleGetTagsForEntityQueryError = void
+
+
+/**
+ * @summary Retrieve the tags on a record.
+ */
+
+export function useArticleGetTagsForEntity<TData = Awaited<ReturnType<typeof articleGetTagsForEntity>>, TError = void>(
+ entityUid: string | null,
+    params?: ArticleGetTagsForEntityParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof articleGetTagsForEntity>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+  
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getArticleGetTagsForEntityQueryOptions(entityUid,params,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  query.queryKey = queryOptions.queryKey ;
+
+  return query;
+}
+
+
+
+
+/**
+ * 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 const articleSetTagsForEntity = (
+    entityUid: string | null,
+    articleSetTagsForEntityBody: ArticleSetTagsForEntityBody,
+ options?: SecondParameter<typeof customFetch>,) => {
+      
+      
+      return customFetch<Blob>(
+      {url: `/api/v1/support/articles/${entityUid}/tags`, method: 'PUT',
+      headers: {'Content-Type': 'application/json', },
+      data: articleSetTagsForEntityBody,
+        responseType: 'blob'
+    },
+      options);
+    }
+  
+
+
+export const getArticleSetTagsForEntityMutationOptions = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof articleSetTagsForEntity>>, TError,{entityUid: string | null;data: ArticleSetTagsForEntityBody}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof articleSetTagsForEntity>>, TError,{entityUid: string | null;data: ArticleSetTagsForEntityBody}, TContext> => {
+
+const mutationKey = ['articleSetTagsForEntity'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+      
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof articleSetTagsForEntity>>, {entityUid: string | null;data: ArticleSetTagsForEntityBody}> = (props) => {
+          const {entityUid,data} = props ?? {};
+
+          return  articleSetTagsForEntity(entityUid,data,requestOptions)
+        }
+
+        
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type ArticleSetTagsForEntityMutationResult = NonNullable<Awaited<ReturnType<typeof articleSetTagsForEntity>>>
+    export type ArticleSetTagsForEntityMutationBody = ArticleSetTagsForEntityBody
+    export type ArticleSetTagsForEntityMutationError = void
+
+    /**
+ * @summary Replace the tags on a record.
+ */
+export const useArticleSetTagsForEntity = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof articleSetTagsForEntity>>, TError,{entityUid: string | null;data: ArticleSetTagsForEntityBody}, TContext>, request?: SecondParameter<typeof customFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof articleSetTagsForEntity>>,
+        TError,
+        {entityUid: string | null;data: ArticleSetTagsForEntityBody},
+        TContext
+      > => {
+
+      const mutationOptions = getArticleSetTagsForEntityMutationOptions(options);
+
+      return useMutation(mutationOptions);
+    }
+    /**
+ * 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 const articleRemoveTagFromEntity = (
+    entityUid: string | null,
+    tagUid: string | null,
+ options?: SecondParameter<typeof customFetch>,) => {
+      
+      
+      return customFetch<Blob>(
+      {url: `/api/v1/support/articles/${entityUid}/tags/${tagUid}`, method: 'DELETE',
+        responseType: 'blob'
+    },
+      options);
+    }
+  
+
+
+export const getArticleRemoveTagFromEntityMutationOptions = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof articleRemoveTagFromEntity>>, TError,{entityUid: string | null;tagUid: string | null}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof articleRemoveTagFromEntity>>, TError,{entityUid: string | null;tagUid: string | null}, TContext> => {
+
+const mutationKey = ['articleRemoveTagFromEntity'];
+const {mutation: mutationOptions, request: requestOptions} = options ?
+      options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
+      options
+      : {...options, mutation: {...options.mutation, mutationKey}}
+      : {mutation: { mutationKey, }, request: undefined};
+
+      
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<typeof articleRemoveTagFromEntity>>, {entityUid: string | null;tagUid: string | null}> = (props) => {
+          const {entityUid,tagUid} = props ?? {};
+
+          return  articleRemoveTagFromEntity(entityUid,tagUid,requestOptions)
+        }
+
+        
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type ArticleRemoveTagFromEntityMutationResult = NonNullable<Awaited<ReturnType<typeof articleRemoveTagFromEntity>>>
+    
+    export type ArticleRemoveTagFromEntityMutationError = void
+
+    /**
+ * @summary Remove one tag from a record.
+ */
+export const useArticleRemoveTagFromEntity = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof articleRemoveTagFromEntity>>, TError,{entityUid: string | null;tagUid: string | null}, TContext>, request?: SecondParameter<typeof customFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof articleRemoveTagFromEntity>>,
+        TError,
+        {entityUid: string | null;tagUid: string | null},
+        TContext
+      > => {
+
+      const mutationOptions = getArticleRemoveTagFromEntityMutationOptions(options);
+
+      return useMutation(mutationOptions);
+    }
+    /**
  * @summary Retrieve all knowledge base categories.
  */
 export const categoryGetAllCategories = (