@djangocfg/api 1.0.1

package/src/cfg/generated/_utils/fetchers/cfg__leads.ts

@@ -0,0 +1,122 @@
+/**
+ * Typed fetchers for Leads
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { LeadSubmissionSchema, type LeadSubmission } from '../schemas/LeadSubmission.schema'
+import { LeadSubmissionRequestSchema, type LeadSubmissionRequest } from '../schemas/LeadSubmissionRequest.schema'
+import { PaginatedLeadSubmissionListSchema, type PaginatedLeadSubmissionList } from '../schemas/PaginatedLeadSubmissionList.schema'
+import { PatchedLeadSubmissionRequestSchema, type PatchedLeadSubmissionRequest } from '../schemas/PatchedLeadSubmissionRequest.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/leads/
+ */
+export async function getLeadsList(  params?: { page?: number; page_size?: number },  client?: API
+): Promise<PaginatedLeadSubmissionList> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_leads.list(params?.page, params?.page_size)
+  return PaginatedLeadSubmissionListSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/leads/
+ */
+export async function createLeadsCreate(  data: LeadSubmissionRequest,  client?: API
+): Promise<LeadSubmission> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_leads.create(data)
+  return LeadSubmissionSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/leads/{id}/
+ */
+export async function getLeadsRetrieve(  id: number,  client?: API
+): Promise<LeadSubmission> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_leads.retrieve(id)
+  return LeadSubmissionSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method PUT
+ * @path /cfg/leads/{id}/
+ */
+export async function updateLeadsUpdate(  id: number, data: LeadSubmissionRequest,  client?: API
+): Promise<LeadSubmission> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_leads.update(id, data)
+  return LeadSubmissionSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/leads/{id}/
+ */
+export async function partialUpdateLeadsPartialUpdate(  id: number, data?: PatchedLeadSubmissionRequest,  client?: API
+): Promise<LeadSubmission> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_leads.partialUpdate(id, data)
+  return LeadSubmissionSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method DELETE
+ * @path /cfg/leads/{id}/
+ */
+export async function deleteLeadsDestroy(  id: number,  client?: API
+): Promise<void> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_leads.destroy(id)
+  return response
+}
+
+

package/src/cfg/generated/_utils/fetchers/cfg__leads__lead_submission.ts

@@ -0,0 +1,50 @@
+/**
+ * Typed fetchers for Lead Submission
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { LeadSubmissionRequestSchema, type LeadSubmissionRequest } from '../schemas/LeadSubmissionRequest.schema'
+import { LeadSubmissionResponseSchema, type LeadSubmissionResponse } from '../schemas/LeadSubmissionResponse.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * Submit Lead Form
+ *
+ * @method POST
+ * @path /cfg/leads/submit/
+ */
+export async function createLeadsSubmitCreate(  data: LeadSubmissionRequest,  client?: API
+): Promise<LeadSubmissionResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_lead_submission.leadsSubmitCreate(data)
+  return LeadSubmissionResponseSchema.parse(response)
+}
+
+

package/src/cfg/generated/_utils/fetchers/cfg__newsletter.ts

@@ -0,0 +1,81 @@
+/**
+ * Typed fetchers for Newsletter
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { NewsletterCampaignSchema, type NewsletterCampaign } from '../schemas/NewsletterCampaign.schema'
+import { PatchedNewsletterCampaignRequestSchema, type PatchedNewsletterCampaignRequest } from '../schemas/PatchedNewsletterCampaignRequest.schema'
+import { PatchedUnsubscribeRequestSchema, type PatchedUnsubscribeRequest } from '../schemas/PatchedUnsubscribeRequest.schema'
+import { UnsubscribeSchema, type Unsubscribe } from '../schemas/Unsubscribe.schema'
+import { UnsubscribeRequestSchema, type UnsubscribeRequest } from '../schemas/UnsubscribeRequest.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/newsletter/campaigns/{id}/
+ */
+export async function partialUpdateNewsletterCampaignsPartialUpdate(  id: number, data?: PatchedNewsletterCampaignRequest,  client?: API
+): Promise<NewsletterCampaign> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_newsletter.campaignsPartialUpdate(id, data)
+  return NewsletterCampaignSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method PUT
+ * @path /cfg/newsletter/unsubscribe/
+ */
+export async function updateNewsletterUnsubscribeUpdate(  data: UnsubscribeRequest,  client?: API
+): Promise<Unsubscribe> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_newsletter.unsubscribeUpdate(data)
+  return UnsubscribeSchema.parse(response)
+}
+
+
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/newsletter/unsubscribe/
+ */
+export async function partialUpdateNewsletterUnsubscribePartialUpdate(  data?: PatchedUnsubscribeRequest,  client?: API
+): Promise<Unsubscribe> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_newsletter.unsubscribePartialUpdate(data)
+  return UnsubscribeSchema.parse(response)
+}
+
+

package/src/cfg/generated/_utils/fetchers/cfg__newsletter__bulk_email.ts

@@ -0,0 +1,50 @@
+/**
+ * Typed fetchers for Bulk Email
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { BulkEmailRequestSchema, type BulkEmailRequest } from '../schemas/BulkEmailRequest.schema'
+import { BulkEmailResponseSchema, type BulkEmailResponse } from '../schemas/BulkEmailResponse.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * Send Bulk Email
+ *
+ * @method POST
+ * @path /cfg/newsletter/bulk/
+ */
+export async function createNewsletterBulkCreate(  data: BulkEmailRequest,  client?: API
+): Promise<BulkEmailResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_bulk_email.newsletterBulkCreate(data)
+  return BulkEmailResponseSchema.parse(response)
+}
+
+

package/src/cfg/generated/_utils/fetchers/cfg__newsletter__campaigns.ts

@@ -0,0 +1,123 @@
+/**
+ * Typed fetchers for Campaigns
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { NewsletterCampaignSchema, type NewsletterCampaign } from '../schemas/NewsletterCampaign.schema'
+import { NewsletterCampaignRequestSchema, type NewsletterCampaignRequest } from '../schemas/NewsletterCampaignRequest.schema'
+import { PaginatedNewsletterCampaignListSchema, type PaginatedNewsletterCampaignList } from '../schemas/PaginatedNewsletterCampaignList.schema'
+import { SendCampaignRequestSchema, type SendCampaignRequest } from '../schemas/SendCampaignRequest.schema'
+import { SendCampaignResponseSchema, type SendCampaignResponse } from '../schemas/SendCampaignResponse.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * List Newsletter Campaigns
+ *
+ * @method GET
+ * @path /cfg/newsletter/campaigns/
+ */
+export async function getNewsletterCampaignsList(  params?: { page?: number; page_size?: number },  client?: API
+): Promise<PaginatedNewsletterCampaignList> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_campaigns.newsletterCampaignsList(params?.page, params?.page_size)
+  return PaginatedNewsletterCampaignListSchema.parse(response)
+}
+
+
+/**
+ * Create Newsletter Campaign
+ *
+ * @method POST
+ * @path /cfg/newsletter/campaigns/
+ */
+export async function createNewsletterCampaignsCreate(  data: NewsletterCampaignRequest,  client?: API
+): Promise<NewsletterCampaign> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_campaigns.newsletterCampaignsCreate(data)
+  return NewsletterCampaignSchema.parse(response)
+}
+
+
+/**
+ * Get Campaign Details
+ *
+ * @method GET
+ * @path /cfg/newsletter/campaigns/{id}/
+ */
+export async function getNewsletterCampaignsRetrieve(  id: number,  client?: API
+): Promise<NewsletterCampaign> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_campaigns.newsletterCampaignsRetrieve(id)
+  return NewsletterCampaignSchema.parse(response)
+}
+
+
+/**
+ * Update Campaign
+ *
+ * @method PUT
+ * @path /cfg/newsletter/campaigns/{id}/
+ */
+export async function updateNewsletterCampaignsUpdate(  id: number, data: NewsletterCampaignRequest,  client?: API
+): Promise<NewsletterCampaign> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_campaigns.newsletterCampaignsUpdate(id, data)
+  return NewsletterCampaignSchema.parse(response)
+}
+
+
+/**
+ * Delete Campaign
+ *
+ * @method DELETE
+ * @path /cfg/newsletter/campaigns/{id}/
+ */
+export async function deleteNewsletterCampaignsDestroy(  id: number,  client?: API
+): Promise<void> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_campaigns.newsletterCampaignsDestroy(id)
+  return response
+}
+
+
+/**
+ * Send Newsletter Campaign
+ *
+ * @method POST
+ * @path /cfg/newsletter/campaigns/send/
+ */
+export async function createNewsletterCampaignsSendCreate(  data: SendCampaignRequest,  client?: API
+): Promise<SendCampaignResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_campaigns.newsletterCampaignsSendCreate(data)
+  return SendCampaignResponseSchema.parse(response)
+}
+
+

package/src/cfg/generated/_utils/fetchers/cfg__newsletter__logs.ts

@@ -0,0 +1,49 @@
+/**
+ * Typed fetchers for Logs
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { PaginatedEmailLogListSchema, type PaginatedEmailLogList } from '../schemas/PaginatedEmailLogList.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * List Email Logs
+ *
+ * @method GET
+ * @path /cfg/newsletter/logs/
+ */
+export async function getNewsletterLogsList(  params?: { page?: number; page_size?: number },  client?: API
+): Promise<PaginatedEmailLogList> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_logs.newsletterLogsList(params?.page, params?.page_size)
+  return PaginatedEmailLogListSchema.parse(response)
+}
+
+

package/src/cfg/generated/_utils/fetchers/cfg__newsletter__newsletters.ts

@@ -0,0 +1,64 @@
+/**
+ * Typed fetchers for Newsletters
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { NewsletterSchema, type Newsletter } from '../schemas/Newsletter.schema'
+import { PaginatedNewsletterListSchema, type PaginatedNewsletterList } from '../schemas/PaginatedNewsletterList.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * List Active Newsletters
+ *
+ * @method GET
+ * @path /cfg/newsletter/newsletters/
+ */
+export async function getNewsletterNewslettersList(  params?: { page?: number; page_size?: number },  client?: API
+): Promise<PaginatedNewsletterList> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_newsletters.newsletterNewslettersList(params?.page, params?.page_size)
+  return PaginatedNewsletterListSchema.parse(response)
+}
+
+
+/**
+ * Get Newsletter Details
+ *
+ * @method GET
+ * @path /cfg/newsletter/newsletters/{id}/
+ */
+export async function getNewsletterNewslettersRetrieve(  id: number,  client?: API
+): Promise<Newsletter> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_newsletters.newsletterNewslettersRetrieve(id)
+  return NewsletterSchema.parse(response)
+}
+
+

package/src/cfg/generated/_utils/fetchers/cfg__newsletter__subscriptions.ts

@@ -0,0 +1,81 @@
+/**
+ * Typed fetchers for Subscriptions
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { PaginatedNewsletterSubscriptionListSchema, type PaginatedNewsletterSubscriptionList } from '../schemas/PaginatedNewsletterSubscriptionList.schema'
+import { SubscribeRequestSchema, type SubscribeRequest } from '../schemas/SubscribeRequest.schema'
+import { SubscribeResponseSchema, type SubscribeResponse } from '../schemas/SubscribeResponse.schema'
+import { SuccessResponseSchema, type SuccessResponse } from '../schemas/SuccessResponse.schema'
+import { UnsubscribeRequestSchema, type UnsubscribeRequest } from '../schemas/UnsubscribeRequest.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * Subscribe to Newsletter
+ *
+ * @method POST
+ * @path /cfg/newsletter/subscribe/
+ */
+export async function createNewsletterSubscribeCreate(  data: SubscribeRequest,  client?: API
+): Promise<SubscribeResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_subscriptions.newsletterSubscribeCreate(data)
+  return SubscribeResponseSchema.parse(response)
+}
+
+
+/**
+ * List User Subscriptions
+ *
+ * @method GET
+ * @path /cfg/newsletter/subscriptions/
+ */
+export async function getNewsletterSubscriptionsList(  params?: { page?: number; page_size?: number },  client?: API
+): Promise<PaginatedNewsletterSubscriptionList> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_subscriptions.newsletterSubscriptionsList(params?.page, params?.page_size)
+  return PaginatedNewsletterSubscriptionListSchema.parse(response)
+}
+
+
+/**
+ * Unsubscribe from Newsletter
+ *
+ * @method POST
+ * @path /cfg/newsletter/unsubscribe/
+ */
+export async function createNewsletterUnsubscribeCreate(  data: UnsubscribeRequest,  client?: API
+): Promise<SuccessResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_subscriptions.newsletterUnsubscribeCreate(data)
+  return SuccessResponseSchema.parse(response)
+}
+
+

package/src/cfg/generated/_utils/fetchers/cfg__newsletter__testing.ts

@@ -0,0 +1,50 @@
+/**
+ * Typed fetchers for Testing
+ *
+ * Universal functions that work in any environment:
+ * - Next.js (App Router / Pages Router / Server Components)
+ * - React Native
+ * - Node.js backend
+ *
+ * These fetchers use Zod schemas for runtime validation.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure API once (in your app entry point)
+ * import { configureAPI } from '../../api-instance'
+ * configureAPI({ baseUrl: 'https://api.example.com' })
+ *
+ * // Then use fetchers anywhere
+ * const users = await getUsers({ page: 1 })
+ *
+ * // With SWR
+ * const { data } = useSWR(['users', params], () => getUsers(params))
+ *
+ * // With React Query
+ * const { data } = useQuery(['users', params], () => getUsers(params))
+ *
+ * // In Server Component or SSR (pass custom client)
+ * import { API } from '../../index'
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+import { BulkEmailResponseSchema, type BulkEmailResponse } from '../schemas/BulkEmailResponse.schema'
+import { TestEmailRequestSchema, type TestEmailRequest } from '../schemas/TestEmailRequest.schema'
+import { getAPIInstance } from '../../api-instance'
+import type { API } from '../../index'
+
+/**
+ * Test Email Sending
+ *
+ * @method POST
+ * @path /cfg/newsletter/test/
+ */
+export async function createNewsletterTestCreate(  data: TestEmailRequest,  client?: API
+): Promise<BulkEmailResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.cfg_testing.newsletterTestCreate(data)
+  return BulkEmailResponseSchema.parse(response)
+}
+
+