@outseta/react 0.4.24 → 0.4.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outseta/react",
-  "version": "0.4.24",
+  "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.30"
+    "@outseta/api-client": "0.3.31"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0"

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.

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);
+    }
+