@outseta/react 0.5.2 → 0.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outseta/react",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "React hooks and components for the Outseta API",
   "license": "MIT",
   "repository": {
@@ -18,7 +18,7 @@
     }
   },
   "dependencies": {
-    "@outseta/api-client": "0.4.2"
+    "@outseta/api-client": "0.4.3"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0"

package/src/generated/outsetaAPI.schemas.ts

@@ -3755,6 +3755,42 @@ export const ActivityType = {
   DiscordUserRemovedFromServer: 503,
 } as const;
 
+export type TemplateAllOf = {
+  /**
+   * @minLength 1
+   * @maxLength 250
+   */
+  Name: string;
+  /**
+   * @maxLength 1000
+   * @nullable
+   */
+  Subject?: string | null;
+  /** @minLength 1 */
+  Body: string;
+  /** @nullable */
+  Design?: string | null;
+  /**
+   * @maxLength 1000
+   * @nullable
+   */
+  Description?: string | null;
+  /**
+   * @maxLength 50
+   * @nullable
+   */
+  SystemName?: string | null;
+  IsInternal?: boolean;
+  /** @nullable */
+  AvailableTokens?: string | null;
+  /** @nullable */
+  RequiredTokens?: string | null;
+  /** @nullable */
+  Tag?: string | null;
+};
+
+export type Template = AbstractQcountBean & TemplateAllOf;
+
 /**
  * @nullable
  */
@@ -3811,41 +3847,34 @@ export type TemplateEmailInstanceAllOf = {
 
 export type TemplateEmailInstance = AbstractQcountBean & TemplateEmailInstanceAllOf;
 
-export type TemplateAllOf = {
-  /**
-   * @minLength 1
-   * @maxLength 250
-   */
-  Name: string;
+/**
+ * The fields of an email template that an update may change. Every field is optional:
+a field left out keeps its current value.
+ */
+export interface UpdateTemplateRequest {
+  /** The HTML of the template. May use Liquid tokens, for example {{ Person.FirstName }},
+and must keep every token in the template's RequiredTokens. Cannot be null. */
+  Body?: string;
   /**
-   * @maxLength 1000
+   * What the template is for. Cannot be changed for a system email.
    * @nullable
    */
-  Subject?: string | null;
-  /** @minLength 1 */
-  Body: string;
-  /** @nullable */
-  Design?: string | null;
+  Description?: string | null;
   /**
-   * @maxLength 1000
+   * The design of the template in the drag-and-drop editor, as JSON. Send null with a new
+Body so the editor opens the new Body as HTML instead of the old design.
    * @nullable
    */
-  Description?: string | null;
+  Design?: string | null;
+  /** The name of the template, shown in the Outseta app. Cannot be changed for a system
+email. Cannot be null. */
+  Name?: string;
   /**
-   * @maxLength 50
+   * The subject line of the email. May use Liquid tokens, for example {{ CompanyName }}.
    * @nullable
    */
-  SystemName?: string | null;
-  IsInternal?: boolean;
-  /** @nullable */
-  AvailableTokens?: string | null;
-  /** @nullable */
-  RequiredTokens?: string | null;
-  /** @nullable */
-  Tag?: string | null;
-};
-
-export type Template = AbstractQcountBean & TemplateAllOf;
+  Subject?: string | null;
+}
 
 export interface SendTemplateEmailRequest {
   /**
@@ -9830,6 +9859,22 @@ export type CategoryGetAllCategories200 = {
   items?: Category[];
 };
 
+export type TemplateGetAllTemplatesParams = {
+/**
+ * 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 TemplateGetAllTemplates200 = {
+  metadata?: CollectionMetadata;
+  items?: Template[];
+};
+
 export type TemplateGetAllTemplateEmailsParams = {
 /**
  * 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/template/template.ts

@@ -14,12 +14,16 @@ import type {
 } from '../../query';
 
 import type {
+  Template,
   TemplateEmailInstance,
   TemplateGetAllTemplateEmails200,
   TemplateGetAllTemplateEmailsParams,
+  TemplateGetAllTemplates200,
+  TemplateGetAllTemplatesParams,
   TemplateGetTemplateEmails200,
   TemplateGetTemplateEmailsParams,
-  TemplateSendTemplateEmailBody
+  TemplateSendTemplateEmailBody,
+  UpdateTemplateRequest
 } from '../outsetaAPI.schemas';
 
 import { customFetch } from '../../mutator';
@@ -29,6 +33,91 @@ type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
 
 
 
+/**
+ * The list holds the templates from Email > Email templates (Tag template), the email
+layouts (Tag layout), the broadcast wrapper (Tag wrapper), the saved support replies
+(Tag savedReply) and the system emails Outseta sends, such as the registration
+confirmation (Tag email). A system email has a SystemName, which never changes. Filter
+with Tag=email or SystemName to find one.
+            
+Body and Design are left out to keep the list small, except that a system email the
+account never edited carries its default Body. Read a template with the get endpoint to
+see its Body and Design.
+            
+A system email the account never edited is not stored yet. It is listed with a Uid
+that starts with int_, which can be used like any other Uid. Saving the system email
+stores the account's own copy, which has a regular Uid from then on. An int_ Uid can
+change when Outseta adds system emails, so keep the SystemName rather than the int_ Uid.
+            
+Internal system emails that accounts cannot change are not listed.
+ * @summary The email templates, layouts and system emails of the account.
+ */
+export const templateGetAllTemplates = (
+    params?: TemplateGetAllTemplatesParams,
+ options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
+) => {
+      
+      
+      return customFetch<TemplateGetAllTemplates200>(
+      {url: `/api/v1/templates`, method: 'GET',
+        params, signal
+    },
+      options);
+    }
+  
+
+
+
+export const getTemplateGetAllTemplatesQueryKey = (params?: TemplateGetAllTemplatesParams,) => {
+    return [
+    `/api/v1/templates`, ...(params ? [params]: [])
+    ] as const;
+    }
+
+    
+export const getTemplateGetAllTemplatesQueryOptions = <TData = Awaited<ReturnType<typeof templateGetAllTemplates>>, TError = void>(params?: TemplateGetAllTemplatesParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof templateGetAllTemplates>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getTemplateGetAllTemplatesQueryKey(params);
+
+  
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof templateGetAllTemplates>>> = ({ signal }) => templateGetAllTemplates(params, requestOptions, signal);
+
+      
+
+      
+
+   return  { queryKey, queryFn, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof templateGetAllTemplates>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type TemplateGetAllTemplatesQueryResult = NonNullable<Awaited<ReturnType<typeof templateGetAllTemplates>>>
+export type TemplateGetAllTemplatesQueryError = void
+
+
+/**
+ * @summary The email templates, layouts and system emails of the account.
+ */
+
+export function useTemplateGetAllTemplates<TData = Awaited<ReturnType<typeof templateGetAllTemplates>>, TError = void>(
+ params?: TemplateGetAllTemplatesParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof templateGetAllTemplates>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+  
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getTemplateGetAllTemplatesQueryOptions(params,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  query.queryKey = queryOptions.queryKey ;
+
+  return query;
+}
+
+
+
+
 /**
  * Filter with personUid to see what one person was sent, or with templateUid to
 restrict the results to a single template.
@@ -176,6 +265,170 @@ export function useTemplateGetTemplateEmails<TData = Awaited<ReturnType<typeof t
 
 
 /**
+ * Body is the HTML of the email; Subject and Body may use Liquid tokens such as
+{{ Person.FirstName }}. AvailableTokens lists the tokens Outseta fills in for a system
+email, and RequiredTokens the ones its Body must keep (for example ConfirmationUrl in the
+registration confirmation).
+            
+Design is the drag-and-drop editor's design of the template as JSON, or null for a
+template that is plain HTML. System emails have no Design.
+            
+A system email the account never edited returns its default content under its int_ Uid
+from the list endpoint.
+ * @summary Get an email template, layout or system email, with its Body and Design.
+ */
+export const templateGetTemplate = (
+    templateUid: string | null,
+ options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
+) => {
+      
+      
+      return customFetch<Template>(
+      {url: `/api/v1/templates/${templateUid}`, method: 'GET', signal
+    },
+      options);
+    }
+  
+
+
+
+export const getTemplateGetTemplateQueryKey = (templateUid?: string | null,) => {
+    return [
+    `/api/v1/templates/${templateUid}`
+    ] as const;
+    }
+
+    
+export const getTemplateGetTemplateQueryOptions = <TData = Awaited<ReturnType<typeof templateGetTemplate>>, TError = void>(templateUid: string | null, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof templateGetTemplate>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getTemplateGetTemplateQueryKey(templateUid);
+
+  
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof templateGetTemplate>>> = ({ signal }) => templateGetTemplate(templateUid, requestOptions, signal);
+
+      
+
+      
+
+   return  { queryKey, queryFn, enabled: !!(templateUid), ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof templateGetTemplate>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type TemplateGetTemplateQueryResult = NonNullable<Awaited<ReturnType<typeof templateGetTemplate>>>
+export type TemplateGetTemplateQueryError = void
+
+
+/**
+ * @summary Get an email template, layout or system email, with its Body and Design.
+ */
+
+export function useTemplateGetTemplate<TData = Awaited<ReturnType<typeof templateGetTemplate>>, TError = void>(
+ templateUid: string | null, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof templateGetTemplate>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+  
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getTemplateGetTemplateQueryOptions(templateUid,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  query.queryKey = queryOptions.queryKey ;
+
+  return query;
+}
+
+
+
+
+/**
+ * Send only the fields to change, usually Subject and Body. Fields left out of the request
+keep their current values; a field sent as null is cleared. The Uid in the request body
+is ignored.
+            
+Subject and Body must be valid Liquid, and Body must keep every token in RequiredTokens
+(for example ConfirmationUrl in the registration confirmation); otherwise the update is
+rejected with a validation error. The Name, Description and SystemName of a system email
+cannot be changed.
+            
+A template with a Design (made in the drag-and-drop editor of Email > Email templates)
+opens in the editor from its Design, not its Body. To change the Body of such a
+template, send Design as null as well: the editor then opens the new Body as HTML.
+Otherwise the editor keeps showing the old design, and saving the template there
+replaces the new Body. System emails have no Design.
+            
+A system email the account never edited has a Uid that starts with int_. Updating it
+stores the account's own copy, with the default content for the fields left out, and
+returns it with its new Uid. From then on Outseta sends the copy; the int_ Uid
+returns 404.
+            
+On an Outseta account that is not verified yet, updating a system email pauses all email
+sending of the account, as it does in the Outseta app.
+ * @summary Update an email template, layout or system email.
+ */
+export const templateUpdateTemplate = (
+    templateUid: string | null,
+    updateTemplateRequest: UpdateTemplateRequest,
+ options?: SecondParameter<typeof customFetch>,) => {
+      
+      
+      return customFetch<Template>(
+      {url: `/api/v1/templates/${templateUid}`, method: 'PUT',
+      headers: {'Content-Type': 'application/json', },
+      data: updateTemplateRequest
+    },
+      options);
+    }
+  
+
+
+export const getTemplateUpdateTemplateMutationOptions = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof templateUpdateTemplate>>, TError,{templateUid: string | null;data: UpdateTemplateRequest}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof templateUpdateTemplate>>, TError,{templateUid: string | null;data: UpdateTemplateRequest}, TContext> => {
+
+const mutationKey = ['templateUpdateTemplate'];
+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 templateUpdateTemplate>>, {templateUid: string | null;data: UpdateTemplateRequest}> = (props) => {
+          const {templateUid,data} = props ?? {};
+
+          return  templateUpdateTemplate(templateUid,data,requestOptions)
+        }
+
+        
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type TemplateUpdateTemplateMutationResult = NonNullable<Awaited<ReturnType<typeof templateUpdateTemplate>>>
+    export type TemplateUpdateTemplateMutationBody = UpdateTemplateRequest
+    export type TemplateUpdateTemplateMutationError = void
+
+    /**
+ * @summary Update an email template, layout or system email.
+ */
+export const useTemplateUpdateTemplate = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof templateUpdateTemplate>>, TError,{templateUid: string | null;data: UpdateTemplateRequest}, TContext>, request?: SecondParameter<typeof customFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof templateUpdateTemplate>>,
+        TError,
+        {templateUid: string | null;data: UpdateTemplateRequest},
+        TContext
+      > => {
+
+      const mutationOptions = getTemplateUpdateTemplateMutationOptions(options);
+
+      return useMutation(mutationOptions);
+    }
+    /**
  * The email is merge-rendered for the person and sent immediately. No broadcast
 is created. People who have bounced, unsubscribed or reported spam are not sent
 the email. Only templates from Email > Email templates can be sent.