@outseta/react 0.4.23 → 0.4.25

package/dist/index.js

@@ -2727,6 +2727,119 @@ var useCampaignSendTestCampaignEmail = (options) => {
   const mutationOptions = getCampaignSendTestCampaignEmailMutationOptions(options);
   return useMutation(mutationOptions);
 };
+var emailListGetAllEmailLists = (params, options, signal) => {
+  return customFetch({
+    url: `/api/v1/email/lists`,
+    method: "GET",
+    params,
+    signal
+  }, options);
+};
+var getEmailListGetAllEmailListsQueryKey = (params) => {
+  return [
+    `/api/v1/email/lists`,
+    ...params ? [params] : []
+  ];
+};
+var getEmailListGetAllEmailListsQueryOptions = (params, options) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+  const queryKey = queryOptions?.queryKey ?? getEmailListGetAllEmailListsQueryKey(params);
+  const queryFn = ({ signal }) => emailListGetAllEmailLists(params, requestOptions, signal);
+  return { queryKey, queryFn, ...queryOptions };
+};
+function useEmailListGetAllEmailLists(params, options) {
+  const queryOptions = getEmailListGetAllEmailListsQueryOptions(params, options);
+  const query = useQuery(queryOptions);
+  query.queryKey = queryOptions.queryKey;
+  return query;
+}
+var emailListAddEmailList = (emailListAddEmailListBody, options, signal) => {
+  return customFetch({
+    url: `/api/v1/email/lists`,
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    data: emailListAddEmailListBody,
+    signal
+  }, options);
+};
+var getEmailListAddEmailListMutationOptions = (options) => {
+  const mutationKey = ["emailListAddEmailList"];
+  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 = (props) => {
+    const { data } = props ?? {};
+    return emailListAddEmailList(data, requestOptions);
+  };
+  return { mutationFn, ...mutationOptions };
+};
+var useEmailListAddEmailList = (options) => {
+  const mutationOptions = getEmailListAddEmailListMutationOptions(options);
+  return useMutation(mutationOptions);
+};
+var emailListGetEmailList = (emailListUid, options, signal) => {
+  return customFetch({
+    url: `/api/v1/email/lists/${emailListUid}`,
+    method: "GET",
+    signal
+  }, options);
+};
+var getEmailListGetEmailListQueryKey = (emailListUid) => {
+  return [
+    `/api/v1/email/lists/${emailListUid}`
+  ];
+};
+var getEmailListGetEmailListQueryOptions = (emailListUid, options) => {
+  const { query: queryOptions, request: requestOptions } = options ?? {};
+  const queryKey = queryOptions?.queryKey ?? getEmailListGetEmailListQueryKey(emailListUid);
+  const queryFn = ({ signal }) => emailListGetEmailList(emailListUid, requestOptions, signal);
+  return { queryKey, queryFn, enabled: !!emailListUid, ...queryOptions };
+};
+function useEmailListGetEmailList(emailListUid, options) {
+  const queryOptions = getEmailListGetEmailListQueryOptions(emailListUid, options);
+  const query = useQuery(queryOptions);
+  query.queryKey = queryOptions.queryKey;
+  return query;
+}
+var emailListUpdateEmailList = (emailListUid, emailListUpdateEmailListBody, options) => {
+  return customFetch({
+    url: `/api/v1/email/lists/${emailListUid}`,
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    data: emailListUpdateEmailListBody
+  }, options);
+};
+var getEmailListUpdateEmailListMutationOptions = (options) => {
+  const mutationKey = ["emailListUpdateEmailList"];
+  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 = (props) => {
+    const { emailListUid, data } = props ?? {};
+    return emailListUpdateEmailList(emailListUid, data, requestOptions);
+  };
+  return { mutationFn, ...mutationOptions };
+};
+var useEmailListUpdateEmailList = (options) => {
+  const mutationOptions = getEmailListUpdateEmailListMutationOptions(options);
+  return useMutation(mutationOptions);
+};
+var emailListDeleteEmailList = (emailListUid, options) => {
+  return customFetch({
+    url: `/api/v1/email/lists/${emailListUid}`,
+    method: "DELETE",
+    responseType: "blob"
+  }, options);
+};
+var getEmailListDeleteEmailListMutationOptions = (options) => {
+  const mutationKey = ["emailListDeleteEmailList"];
+  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 = (props) => {
+    const { emailListUid } = props ?? {};
+    return emailListDeleteEmailList(emailListUid, requestOptions);
+  };
+  return { mutationFn, ...mutationOptions };
+};
+var useEmailListDeleteEmailList = (options) => {
+  const mutationOptions = getEmailListDeleteEmailListMutationOptions(options);
+  return useMutation(mutationOptions);
+};
 var emailListGetAllSubscriptions = (emailListUid, params, options, signal) => {
   return customFetch({
     url: `/api/v1/email/lists/${emailListUid}/subscriptions`,
@@ -3611,9 +3724,14 @@ export {
   useInvoiceGetAllInvoices,
   useInvoiceDeleteInvoice,
   useInvoiceAddInvoice,
+  useEmailListUpdateEmailList,
+  useEmailListGetEmailList,
   useEmailListGetAllSubscriptions,
+  useEmailListGetAllEmailLists,
   useEmailListDeleteSubscription,
+  useEmailListDeleteEmailList,
   useEmailListAddSubscription,
+  useEmailListAddEmailList,
   useDripCampaignUpdateDripCampaignMessage,
   useDripCampaignUpdateDripCampaign,
   useDripCampaignSendTestCampaignEmail,
@@ -3777,10 +3895,17 @@ export {
   getInvoiceGetAllInvoicesQueryKey,
   getInvoiceDeleteInvoiceMutationOptions,
   getInvoiceAddInvoiceMutationOptions,
+  getEmailListUpdateEmailListMutationOptions,
+  getEmailListGetEmailListQueryOptions,
+  getEmailListGetEmailListQueryKey,
   getEmailListGetAllSubscriptionsQueryOptions,
   getEmailListGetAllSubscriptionsQueryKey,
+  getEmailListGetAllEmailListsQueryOptions,
+  getEmailListGetAllEmailListsQueryKey,
   getEmailListDeleteSubscriptionMutationOptions,
+  getEmailListDeleteEmailListMutationOptions,
   getEmailListAddSubscriptionMutationOptions,
+  getEmailListAddEmailListMutationOptions,
   getDripCampaignUpdateDripCampaignMutationOptions,
   getDripCampaignUpdateDripCampaignMessageMutationOptions,
   getDripCampaignSendTestCampaignEmailMutationOptions,
@@ -3853,9 +3978,14 @@ export {
   getAccountCancelAccountMutationOptions,
   getAccountAddPersonToAccountMutationOptions,
   getAccountAddAccountMutationOptions,
+  emailListUpdateEmailList,
+  emailListGetEmailList,
   emailListGetAllSubscriptions,
+  emailListGetAllEmailLists,
   emailListDeleteSubscription,
+  emailListDeleteEmailList,
   emailListAddSubscription,
+  emailListAddEmailList,
   dripCampaignUpdateDripCampaignMessage,
   dripCampaignUpdateDripCampaign,
   dripCampaignSendTestCampaignEmail,

package/package.json

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

package/src/generated/email/email.ts

@@ -29,10 +29,15 @@ import type {
   DripCampaignSendTestCampaignEmailBody,
   DripCampaignUpdateDripCampaignBody,
   DripCampaignUpdateDripCampaignMessageBody,
+  EmailList,
+  EmailListAddEmailListBody,
   EmailListAddSubscriptionBody,
+  EmailListGetAllEmailLists200,
+  EmailListGetAllEmailListsParams,
   EmailListGetAllSubscriptions200,
   EmailListGetAllSubscriptionsParams,
-  EmailListPerson
+  EmailListPerson,
+  EmailListUpdateEmailListBody
 } from '../outsetaAPI.schemas';
 
 import { customFetch } from '../../mutator';
@@ -1319,6 +1324,338 @@ export const useCampaignSendTestCampaignEmail = <TError = void,
       return useMutation(mutationOptions);
     }
     /**
+ * @summary Retrieve all email lists.
+ */
+export const emailListGetAllEmailLists = (
+    params?: EmailListGetAllEmailListsParams,
+ options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
+) => {
+      
+      
+      return customFetch<EmailListGetAllEmailLists200>(
+      {url: `/api/v1/email/lists`, method: 'GET',
+        params, signal
+    },
+      options);
+    }
+  
+
+
+
+export const getEmailListGetAllEmailListsQueryKey = (params?: EmailListGetAllEmailListsParams,) => {
+    return [
+    `/api/v1/email/lists`, ...(params ? [params]: [])
+    ] as const;
+    }
+
+    
+export const getEmailListGetAllEmailListsQueryOptions = <TData = Awaited<ReturnType<typeof emailListGetAllEmailLists>>, TError = void>(params?: EmailListGetAllEmailListsParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof emailListGetAllEmailLists>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getEmailListGetAllEmailListsQueryKey(params);
+
+  
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof emailListGetAllEmailLists>>> = ({ signal }) => emailListGetAllEmailLists(params, requestOptions, signal);
+
+      
+
+      
+
+   return  { queryKey, queryFn, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof emailListGetAllEmailLists>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type EmailListGetAllEmailListsQueryResult = NonNullable<Awaited<ReturnType<typeof emailListGetAllEmailLists>>>
+export type EmailListGetAllEmailListsQueryError = void
+
+
+/**
+ * @summary Retrieve all email lists.
+ */
+
+export function useEmailListGetAllEmailLists<TData = Awaited<ReturnType<typeof emailListGetAllEmailLists>>, TError = void>(
+ params?: EmailListGetAllEmailListsParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof emailListGetAllEmailLists>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+  
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getEmailListGetAllEmailListsQueryOptions(params,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  query.queryKey = queryOptions.queryKey ;
+
+  return query;
+}
+
+
+
+
+/**
+ * Name is required and must be unique. Set RequiresDoubleOptIn to true to require new
+subscribers to confirm their subscription. WelcomeSubject and WelcomeBody configure an
+optional welcome email; use WelcomeFromName and WelcomeFromEmail to set its sender.
+ * @summary Create an email list.
+ */
+export const emailListAddEmailList = (
+    emailListAddEmailListBody: NonReadonly<EmailListAddEmailListBody>,
+ options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
+) => {
+      
+      
+      return customFetch<EmailList>(
+      {url: `/api/v1/email/lists`, method: 'POST',
+      headers: {'Content-Type': 'application/json', },
+      data: emailListAddEmailListBody, signal
+    },
+      options);
+    }
+  
+
+
+export const getEmailListAddEmailListMutationOptions = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof emailListAddEmailList>>, TError,{data: NonReadonly<EmailListAddEmailListBody>}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof emailListAddEmailList>>, TError,{data: NonReadonly<EmailListAddEmailListBody>}, TContext> => {
+
+const mutationKey = ['emailListAddEmailList'];
+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 emailListAddEmailList>>, {data: NonReadonly<EmailListAddEmailListBody>}> = (props) => {
+          const {data} = props ?? {};
+
+          return  emailListAddEmailList(data,requestOptions)
+        }
+
+        
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type EmailListAddEmailListMutationResult = NonNullable<Awaited<ReturnType<typeof emailListAddEmailList>>>
+    export type EmailListAddEmailListMutationBody = NonReadonly<EmailListAddEmailListBody>
+    export type EmailListAddEmailListMutationError = void
+
+    /**
+ * @summary Create an email list.
+ */
+export const useEmailListAddEmailList = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof emailListAddEmailList>>, TError,{data: NonReadonly<EmailListAddEmailListBody>}, TContext>, request?: SecondParameter<typeof customFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof emailListAddEmailList>>,
+        TError,
+        {data: NonReadonly<EmailListAddEmailListBody>},
+        TContext
+      > => {
+
+      const mutationOptions = getEmailListAddEmailListMutationOptions(options);
+
+      return useMutation(mutationOptions);
+    }
+    /**
+ * @summary Retrieve an email list.
+ */
+export const emailListGetEmailList = (
+    emailListUid: string | null,
+ options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
+) => {
+      
+      
+      return customFetch<EmailList>(
+      {url: `/api/v1/email/lists/${emailListUid}`, method: 'GET', signal
+    },
+      options);
+    }
+  
+
+
+
+export const getEmailListGetEmailListQueryKey = (emailListUid?: string | null,) => {
+    return [
+    `/api/v1/email/lists/${emailListUid}`
+    ] as const;
+    }
+
+    
+export const getEmailListGetEmailListQueryOptions = <TData = Awaited<ReturnType<typeof emailListGetEmailList>>, TError = void>(emailListUid: string | null, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof emailListGetEmailList>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getEmailListGetEmailListQueryKey(emailListUid);
+
+  
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof emailListGetEmailList>>> = ({ signal }) => emailListGetEmailList(emailListUid, requestOptions, signal);
+
+      
+
+      
+
+   return  { queryKey, queryFn, enabled: !!(emailListUid), ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof emailListGetEmailList>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type EmailListGetEmailListQueryResult = NonNullable<Awaited<ReturnType<typeof emailListGetEmailList>>>
+export type EmailListGetEmailListQueryError = void
+
+
+/**
+ * @summary Retrieve an email list.
+ */
+
+export function useEmailListGetEmailList<TData = Awaited<ReturnType<typeof emailListGetEmailList>>, TError = void>(
+ emailListUid: string | null, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof emailListGetEmailList>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+  
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getEmailListGetEmailListQueryOptions(emailListUid,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  query.queryKey = queryOptions.queryKey ;
+
+  return query;
+}
+
+
+
+
+/**
+ * The Uid may be omitted from the request body. If supplied, it must match the Uid in the URL.
+ * @summary Update an email list.
+ */
+export const emailListUpdateEmailList = (
+    emailListUid: string | null,
+    emailListUpdateEmailListBody: NonReadonly<EmailListUpdateEmailListBody>,
+ options?: SecondParameter<typeof customFetch>,) => {
+      
+      
+      return customFetch<EmailList>(
+      {url: `/api/v1/email/lists/${emailListUid}`, method: 'PUT',
+      headers: {'Content-Type': 'application/json', },
+      data: emailListUpdateEmailListBody
+    },
+      options);
+    }
+  
+
+
+export const getEmailListUpdateEmailListMutationOptions = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof emailListUpdateEmailList>>, TError,{emailListUid: string | null;data: NonReadonly<EmailListUpdateEmailListBody>}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof emailListUpdateEmailList>>, TError,{emailListUid: string | null;data: NonReadonly<EmailListUpdateEmailListBody>}, TContext> => {
+
+const mutationKey = ['emailListUpdateEmailList'];
+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 emailListUpdateEmailList>>, {emailListUid: string | null;data: NonReadonly<EmailListUpdateEmailListBody>}> = (props) => {
+          const {emailListUid,data} = props ?? {};
+
+          return  emailListUpdateEmailList(emailListUid,data,requestOptions)
+        }
+
+        
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type EmailListUpdateEmailListMutationResult = NonNullable<Awaited<ReturnType<typeof emailListUpdateEmailList>>>
+    export type EmailListUpdateEmailListMutationBody = NonReadonly<EmailListUpdateEmailListBody>
+    export type EmailListUpdateEmailListMutationError = void
+
+    /**
+ * @summary Update an email list.
+ */
+export const useEmailListUpdateEmailList = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof emailListUpdateEmailList>>, TError,{emailListUid: string | null;data: NonReadonly<EmailListUpdateEmailListBody>}, TContext>, request?: SecondParameter<typeof customFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof emailListUpdateEmailList>>,
+        TError,
+        {emailListUid: string | null;data: NonReadonly<EmailListUpdateEmailListBody>},
+        TContext
+      > => {
+
+      const mutationOptions = getEmailListUpdateEmailListMutationOptions(options);
+
+      return useMutation(mutationOptions);
+    }
+    /**
+ * Deleting a list also removes all of its subscriptions.
+ * @summary Delete an email list.
+ */
+export const emailListDeleteEmailList = (
+    emailListUid: string | null,
+ options?: SecondParameter<typeof customFetch>,) => {
+      
+      
+      return customFetch<Blob>(
+      {url: `/api/v1/email/lists/${emailListUid}`, method: 'DELETE',
+        responseType: 'blob'
+    },
+      options);
+    }
+  
+
+
+export const getEmailListDeleteEmailListMutationOptions = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof emailListDeleteEmailList>>, TError,{emailListUid: string | null}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof emailListDeleteEmailList>>, TError,{emailListUid: string | null}, TContext> => {
+
+const mutationKey = ['emailListDeleteEmailList'];
+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 emailListDeleteEmailList>>, {emailListUid: string | null}> = (props) => {
+          const {emailListUid} = props ?? {};
+
+          return  emailListDeleteEmailList(emailListUid,requestOptions)
+        }
+
+        
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type EmailListDeleteEmailListMutationResult = NonNullable<Awaited<ReturnType<typeof emailListDeleteEmailList>>>
+    
+    export type EmailListDeleteEmailListMutationError = void
+
+    /**
+ * @summary Delete an email list.
+ */
+export const useEmailListDeleteEmailList = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof emailListDeleteEmailList>>, TError,{emailListUid: string | null}, TContext>, request?: SecondParameter<typeof customFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof emailListDeleteEmailList>>,
+        TError,
+        {emailListUid: string | null},
+        TContext
+      > => {
+
+      const mutationOptions = getEmailListDeleteEmailListMutationOptions(options);
+
+      return useMutation(mutationOptions);
+    }
+    /**
  * @summary Retrieve all subscribers to an email list.
  */
 export const emailListGetAllSubscriptions = (

package/src/generated/outsetaAPI.schemas.ts

@@ -3658,6 +3658,62 @@ export const ActivityType = {
   DiscordUserRemovedFromServer: 503,
 } as const;
 
+/**
+ * @nullable
+ */
+export type TemplateEmailInstanceAllOfTemplate = Template | null;
+
+/**
+ * @nullable
+ */
+export type TemplateEmailInstanceAllOfRecipient = Person | null;
+
+export type TemplateEmailInstanceAllOf = {
+  /** @nullable */
+  Template?: TemplateEmailInstanceAllOfTemplate;
+  /** @nullable */
+  Recipient?: TemplateEmailInstanceAllOfRecipient;
+  /**
+   * @maxLength 50
+   * @nullable
+   */
+  UniqueMessageId?: string | null;
+  /**
+   * @maxLength 1000
+   * @nullable
+   */
+  Subject?: string | null;
+  /**
+   * @maxLength 250
+   * @nullable
+   */
+  FromEmail?: string | null;
+  /**
+   * @maxLength 250
+   * @nullable
+   */
+  FromName?: string | null;
+  SendDateTime?: string;
+  /** @nullable */
+  ProcessDateTime?: string | null;
+  /** @nullable */
+  DeliverDateTime?: string | null;
+  /** @nullable */
+  BounceDateTime?: string | null;
+  /** @nullable */
+  SpamDateTime?: string | null;
+  /** @nullable */
+  OpenDateTime?: string | null;
+  /** @nullable */
+  ClickDateTime?: string | null;
+  /** @nullable */
+  UnsubscribeDateTime?: string | null;
+  /** @nullable */
+  SendError?: string | null;
+};
+
+export type TemplateEmailInstance = AbstractQcountBean & TemplateEmailInstanceAllOf;
+
 export type TemplateAllOf = {
   /**
    * @minLength 1
@@ -3694,6 +3750,29 @@ export type TemplateAllOf = {
 
 export type Template = AbstractQcountBean & TemplateAllOf;
 
+export interface SendTemplateEmailRequest {
+  /**
+   * The Uid of the person to send the email to. Required.
+   * @nullable
+   */
+  PersonUid?: string | null;
+  /**
+   * The from address. Defaults to the support email address for the account.
+   * @nullable
+   */
+  FromEmail?: string | null;
+  /**
+   * The from name. Defaults to the company name.
+   * @nullable
+   */
+  FromName?: string | null;
+  /**
+   * Overrides the subject of the template.
+   * @nullable
+   */
+  Subject?: string | null;
+}
+
 export type SendGridDomainAuthenticationAllOf = {
   /**
    * @minLength 1
@@ -9185,6 +9264,43 @@ export type CategoryGetAllCategories200 = {
   items?: Category[];
 };
 
+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.
+ */
+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 TemplateGetAllTemplateEmails200 = {
+  metadata?: CollectionMetadata;
+  items?: TemplateEmailInstance[];
+};
+
+export type TemplateGetTemplateEmailsParams = {
+/**
+ * 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 TemplateGetTemplateEmails200 = {
+  metadata?: CollectionMetadata;
+  items?: TemplateEmailInstance[];
+};
+
+/**
+ * @nullable
+ */
+export type TemplateSendTemplateEmailBody = SendTemplateEmailRequest | null;
+
 export type DripCampaignGetAllDripCampaignsParams = {
 /**
  * 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.
@@ -9257,6 +9373,32 @@ export type CampaignUpdateBroadcastEmailBody = BroadcastCampaign | null;
  */
 export type CampaignSendTestCampaignEmailBody = SendTestEmailRequest2 | 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.
+ */
+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 EmailListGetAllEmailLists200 = {
+  metadata?: CollectionMetadata;
+  items?: EmailList[];
+};
+
+/**
+ * @nullable
+ */
+export type EmailListAddEmailListBody = EmailList | null;
+
+/**
+ * @nullable
+ */
+export type EmailListUpdateEmailListBody = EmailList | null;
+
 export type EmailListGetAllSubscriptionsParams = {
 /**
  * Matches person's first name or last name or email address.

package/src/generated/template/template.ts

@@ -0,0 +1,251 @@
+// @ts-nocheck
+import {
+  useMutation,
+  useQuery
+} from '../../query';
+import type {
+  MutationFunction,
+  QueryFunction,
+  QueryKey,
+  UseMutationOptions,
+  UseMutationResult,
+  UseQueryOptions,
+  UseQueryResult
+} from '../../query';
+
+import type {
+  TemplateEmailInstance,
+  TemplateGetAllTemplateEmails200,
+  TemplateGetAllTemplateEmailsParams,
+  TemplateGetTemplateEmails200,
+  TemplateGetTemplateEmailsParams,
+  TemplateSendTemplateEmailBody
+} from '../outsetaAPI.schemas';
+
+import { customFetch } from '../../mutator';
+
+
+type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];
+
+
+
+/**
+ * Filter with personUid to see what one person was sent, or with templateUid to
+restrict the results to a single template.
+ * @summary The one-off emails that were sent from any email template.
+ */
+export const templateGetAllTemplateEmails = (
+    params?: TemplateGetAllTemplateEmailsParams,
+ options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
+) => {
+      
+      
+      return customFetch<TemplateGetAllTemplateEmails200>(
+      {url: `/api/v1/templates/emails`, method: 'GET',
+        params, signal
+    },
+      options);
+    }
+  
+
+
+
+export const getTemplateGetAllTemplateEmailsQueryKey = (params?: TemplateGetAllTemplateEmailsParams,) => {
+    return [
+    `/api/v1/templates/emails`, ...(params ? [params]: [])
+    ] as const;
+    }
+
+    
+export const getTemplateGetAllTemplateEmailsQueryOptions = <TData = Awaited<ReturnType<typeof templateGetAllTemplateEmails>>, TError = void>(params?: TemplateGetAllTemplateEmailsParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof templateGetAllTemplateEmails>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getTemplateGetAllTemplateEmailsQueryKey(params);
+
+  
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof templateGetAllTemplateEmails>>> = ({ signal }) => templateGetAllTemplateEmails(params, requestOptions, signal);
+
+      
+
+      
+
+   return  { queryKey, queryFn, ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof templateGetAllTemplateEmails>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type TemplateGetAllTemplateEmailsQueryResult = NonNullable<Awaited<ReturnType<typeof templateGetAllTemplateEmails>>>
+export type TemplateGetAllTemplateEmailsQueryError = void
+
+
+/**
+ * @summary The one-off emails that were sent from any email template.
+ */
+
+export function useTemplateGetAllTemplateEmails<TData = Awaited<ReturnType<typeof templateGetAllTemplateEmails>>, TError = void>(
+ params?: TemplateGetAllTemplateEmailsParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof templateGetAllTemplateEmails>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+  
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getTemplateGetAllTemplateEmailsQueryOptions(params,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  query.queryKey = queryOptions.queryKey ;
+
+  return query;
+}
+
+
+
+
+/**
+ * Add personUid to the query string to see what one person was sent from this
+template.
+ * @summary The one-off emails that were sent from this email template.
+ */
+export const templateGetTemplateEmails = (
+    templateUid: string | null,
+    params?: TemplateGetTemplateEmailsParams,
+ options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
+) => {
+      
+      
+      return customFetch<TemplateGetTemplateEmails200>(
+      {url: `/api/v1/templates/${templateUid}/emails`, method: 'GET',
+        params, signal
+    },
+      options);
+    }
+  
+
+
+
+export const getTemplateGetTemplateEmailsQueryKey = (templateUid?: string | null,
+    params?: TemplateGetTemplateEmailsParams,) => {
+    return [
+    `/api/v1/templates/${templateUid}/emails`, ...(params ? [params]: [])
+    ] as const;
+    }
+
+    
+export const getTemplateGetTemplateEmailsQueryOptions = <TData = Awaited<ReturnType<typeof templateGetTemplateEmails>>, TError = void>(templateUid: string | null,
+    params?: TemplateGetTemplateEmailsParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof templateGetTemplateEmails>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+) => {
+
+const {query: queryOptions, request: requestOptions} = options ?? {};
+
+  const queryKey =  queryOptions?.queryKey ?? getTemplateGetTemplateEmailsQueryKey(templateUid,params);
+
+  
+
+    const queryFn: QueryFunction<Awaited<ReturnType<typeof templateGetTemplateEmails>>> = ({ signal }) => templateGetTemplateEmails(templateUid,params, requestOptions, signal);
+
+      
+
+      
+
+   return  { queryKey, queryFn, enabled: !!(templateUid), ...queryOptions} as UseQueryOptions<Awaited<ReturnType<typeof templateGetTemplateEmails>>, TError, TData> & { queryKey: QueryKey }
+}
+
+export type TemplateGetTemplateEmailsQueryResult = NonNullable<Awaited<ReturnType<typeof templateGetTemplateEmails>>>
+export type TemplateGetTemplateEmailsQueryError = void
+
+
+/**
+ * @summary The one-off emails that were sent from this email template.
+ */
+
+export function useTemplateGetTemplateEmails<TData = Awaited<ReturnType<typeof templateGetTemplateEmails>>, TError = void>(
+ templateUid: string | null,
+    params?: TemplateGetTemplateEmailsParams, options?: { query?:UseQueryOptions<Awaited<ReturnType<typeof templateGetTemplateEmails>>, TError, TData>, request?: SecondParameter<typeof customFetch>}
+  
+ ):  UseQueryResult<TData, TError> & { queryKey: QueryKey } {
+
+  const queryOptions = getTemplateGetTemplateEmailsQueryOptions(templateUid,params,options)
+
+  const query = useQuery(queryOptions) as  UseQueryResult<TData, TError> & { queryKey: QueryKey };
+
+  query.queryKey = queryOptions.queryKey ;
+
+  return query;
+}
+
+
+
+
+/**
+ * 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.
+            
+The response holds the record of the send. Read the open and click analytics
+for it later from the emails endpoint for the template. The template and the
+recipient are left out of the response unless they are asked for, for example
+fields=*,Template.Uid,Recipient.Uid.
+ * @summary Send an email template to a single person as a one-off email.
+ */
+export const templateSendTemplateEmail = (
+    templateUid: string | null,
+    templateSendTemplateEmailBody: TemplateSendTemplateEmailBody,
+ options?: SecondParameter<typeof customFetch>,signal?: AbortSignal
+) => {
+      
+      
+      return customFetch<TemplateEmailInstance>(
+      {url: `/api/v1/templates/${templateUid}/send`, method: 'POST',
+      headers: {'Content-Type': 'application/json', },
+      data: templateSendTemplateEmailBody, signal
+    },
+      options);
+    }
+  
+
+
+export const getTemplateSendTemplateEmailMutationOptions = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof templateSendTemplateEmail>>, TError,{templateUid: string | null;data: TemplateSendTemplateEmailBody}, TContext>, request?: SecondParameter<typeof customFetch>}
+): UseMutationOptions<Awaited<ReturnType<typeof templateSendTemplateEmail>>, TError,{templateUid: string | null;data: TemplateSendTemplateEmailBody}, TContext> => {
+
+const mutationKey = ['templateSendTemplateEmail'];
+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 templateSendTemplateEmail>>, {templateUid: string | null;data: TemplateSendTemplateEmailBody}> = (props) => {
+          const {templateUid,data} = props ?? {};
+
+          return  templateSendTemplateEmail(templateUid,data,requestOptions)
+        }
+
+        
+
+
+  return  { mutationFn, ...mutationOptions }}
+
+    export type TemplateSendTemplateEmailMutationResult = NonNullable<Awaited<ReturnType<typeof templateSendTemplateEmail>>>
+    export type TemplateSendTemplateEmailMutationBody = TemplateSendTemplateEmailBody
+    export type TemplateSendTemplateEmailMutationError = void
+
+    /**
+ * @summary Send an email template to a single person as a one-off email.
+ */
+export const useTemplateSendTemplateEmail = <TError = void,
+    TContext = unknown>(options?: { mutation?:UseMutationOptions<Awaited<ReturnType<typeof templateSendTemplateEmail>>, TError,{templateUid: string | null;data: TemplateSendTemplateEmailBody}, TContext>, request?: SecondParameter<typeof customFetch>}
+ ): UseMutationResult<
+        Awaited<ReturnType<typeof templateSendTemplateEmail>>,
+        TError,
+        {templateUid: string | null;data: TemplateSendTemplateEmailBody},
+        TContext
+      > => {
+
+      const mutationOptions = getTemplateSendTemplateEmailMutationOptions(options);
+
+      return useMutation(mutationOptions);
+    }
+