@djangocfg/ext-newsletter 1.0.0

package/src/api/generated/ext_newsletter/_utils/fetchers/ext_newsletter__newsletter__subscriptions.ts

@@ -0,0 +1,210 @@
+/**
+ * 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 { consola } from 'consola'
+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'
+
+/**
+ * Subscribe to Newsletter
+ *
+ * @method POST
+ * @path /cfg/newsletter/subscribe/
+ */
+export async function createNewsletterSubscribeCreate(  data: SubscribeRequest,  client?: any
+): Promise<SubscribeResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.ext_newsletter_subscriptions.newsletterSubscribeCreate(data)
+  try {
+    return SubscribeResponseSchema.parse(response)
+  } catch (error) {
+    // Zod validation error - log detailed information
+    consola.error('❌ Zod Validation Failed');
+    consola.box(`createNewsletterSubscribeCreate\nPath: /cfg/newsletter/subscribe/\nMethod: POST`);
+
+    if (error instanceof Error && 'issues' in error && Array.isArray((error as any).issues)) {
+      consola.error('Validation Issues:');
+      (error as any).issues.forEach((issue: any, index: number) => {
+        consola.error(`  ${index + 1}. ${issue.path.join('.') || 'root'}`);
+        consola.error(`     ├─ Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     ├─ Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     └─ Received: ${issue.received}`);
+      });
+    }
+
+    consola.error('Response data:', response);
+
+    // Dispatch browser CustomEvent (only if window is defined)
+    if (typeof window !== 'undefined' && error instanceof Error && 'issues' in error) {
+      try {
+        const event = new CustomEvent('zod-validation-error', {
+          detail: {
+            operation: 'createNewsletterSubscribeCreate',
+            path: '/cfg/newsletter/subscribe/',
+            method: 'POST',
+            error: error,
+            response: response,
+            timestamp: new Date(),
+          },
+          bubbles: true,
+          cancelable: false,
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        // Silently fail - event dispatch should never crash the app
+        consola.warn('Failed to dispatch validation error event:', eventError);
+      }
+    }
+
+    // Re-throw the error
+    throw error;
+  }
+}
+
+
+/**
+ * List User Subscriptions
+ *
+ * @method GET
+ * @path /cfg/newsletter/subscriptions/
+ */
+export async function getNewsletterSubscriptionsList(  params?: { page?: number; page_size?: number },  client?: any
+): Promise<PaginatedNewsletterSubscriptionList> {
+  const api = client || getAPIInstance()
+  const response = await api.ext_newsletter_subscriptions.newsletterSubscriptionsList(params?.page, params?.page_size)
+  try {
+    return PaginatedNewsletterSubscriptionListSchema.parse(response)
+  } catch (error) {
+    // Zod validation error - log detailed information
+    consola.error('❌ Zod Validation Failed');
+    consola.box(`getNewsletterSubscriptionsList\nPath: /cfg/newsletter/subscriptions/\nMethod: GET`);
+
+    if (error instanceof Error && 'issues' in error && Array.isArray((error as any).issues)) {
+      consola.error('Validation Issues:');
+      (error as any).issues.forEach((issue: any, index: number) => {
+        consola.error(`  ${index + 1}. ${issue.path.join('.') || 'root'}`);
+        consola.error(`     ├─ Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     ├─ Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     └─ Received: ${issue.received}`);
+      });
+    }
+
+    consola.error('Response data:', response);
+
+    // Dispatch browser CustomEvent (only if window is defined)
+    if (typeof window !== 'undefined' && error instanceof Error && 'issues' in error) {
+      try {
+        const event = new CustomEvent('zod-validation-error', {
+          detail: {
+            operation: 'getNewsletterSubscriptionsList',
+            path: '/cfg/newsletter/subscriptions/',
+            method: 'GET',
+            error: error,
+            response: response,
+            timestamp: new Date(),
+          },
+          bubbles: true,
+          cancelable: false,
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        // Silently fail - event dispatch should never crash the app
+        consola.warn('Failed to dispatch validation error event:', eventError);
+      }
+    }
+
+    // Re-throw the error
+    throw error;
+  }
+}
+
+
+/**
+ * Unsubscribe from Newsletter
+ *
+ * @method POST
+ * @path /cfg/newsletter/unsubscribe/
+ */
+export async function createNewsletterUnsubscribeCreate(  data: UnsubscribeRequest,  client?: any
+): Promise<SuccessResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.ext_newsletter_subscriptions.newsletterUnsubscribeCreate(data)
+  try {
+    return SuccessResponseSchema.parse(response)
+  } catch (error) {
+    // Zod validation error - log detailed information
+    consola.error('❌ Zod Validation Failed');
+    consola.box(`createNewsletterUnsubscribeCreate\nPath: /cfg/newsletter/unsubscribe/\nMethod: POST`);
+
+    if (error instanceof Error && 'issues' in error && Array.isArray((error as any).issues)) {
+      consola.error('Validation Issues:');
+      (error as any).issues.forEach((issue: any, index: number) => {
+        consola.error(`  ${index + 1}. ${issue.path.join('.') || 'root'}`);
+        consola.error(`     ├─ Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     ├─ Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     └─ Received: ${issue.received}`);
+      });
+    }
+
+    consola.error('Response data:', response);
+
+    // Dispatch browser CustomEvent (only if window is defined)
+    if (typeof window !== 'undefined' && error instanceof Error && 'issues' in error) {
+      try {
+        const event = new CustomEvent('zod-validation-error', {
+          detail: {
+            operation: 'createNewsletterUnsubscribeCreate',
+            path: '/cfg/newsletter/unsubscribe/',
+            method: 'POST',
+            error: error,
+            response: response,
+            timestamp: new Date(),
+          },
+          bubbles: true,
+          cancelable: false,
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        // Silently fail - event dispatch should never crash the app
+        consola.warn('Failed to dispatch validation error event:', eventError);
+      }
+    }
+
+    // Re-throw the error
+    throw error;
+  }
+}
+
+

package/src/api/generated/ext_newsletter/_utils/fetchers/ext_newsletter__newsletter__testing.ts

@@ -0,0 +1,93 @@
+/**
+ * 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 { consola } from 'consola'
+import { BulkEmailResponseSchema, type BulkEmailResponse } from '../schemas/BulkEmailResponse.schema'
+import { TestEmailRequestSchema, type TestEmailRequest } from '../schemas/TestEmailRequest.schema'
+import { getAPIInstance } from '../../api-instance'
+
+/**
+ * Test Email Sending
+ *
+ * @method POST
+ * @path /cfg/newsletter/test/
+ */
+export async function createNewsletterTestCreate(  data: TestEmailRequest,  client?: any
+): Promise<BulkEmailResponse> {
+  const api = client || getAPIInstance()
+  const response = await api.ext_newsletter_testing.newsletterTestCreate(data)
+  try {
+    return BulkEmailResponseSchema.parse(response)
+  } catch (error) {
+    // Zod validation error - log detailed information
+    consola.error('❌ Zod Validation Failed');
+    consola.box(`createNewsletterTestCreate\nPath: /cfg/newsletter/test/\nMethod: POST`);
+
+    if (error instanceof Error && 'issues' in error && Array.isArray((error as any).issues)) {
+      consola.error('Validation Issues:');
+      (error as any).issues.forEach((issue: any, index: number) => {
+        consola.error(`  ${index + 1}. ${issue.path.join('.') || 'root'}`);
+        consola.error(`     ├─ Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     ├─ Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     └─ Received: ${issue.received}`);
+      });
+    }
+
+    consola.error('Response data:', response);
+
+    // Dispatch browser CustomEvent (only if window is defined)
+    if (typeof window !== 'undefined' && error instanceof Error && 'issues' in error) {
+      try {
+        const event = new CustomEvent('zod-validation-error', {
+          detail: {
+            operation: 'createNewsletterTestCreate',
+            path: '/cfg/newsletter/test/',
+            method: 'POST',
+            error: error,
+            response: response,
+            timestamp: new Date(),
+          },
+          bubbles: true,
+          cancelable: false,
+        });
+        window.dispatchEvent(event);
+      } catch (eventError) {
+        // Silently fail - event dispatch should never crash the app
+        consola.warn('Failed to dispatch validation error event:', eventError);
+      }
+    }
+
+    // Re-throw the error
+    throw error;
+  }
+}
+
+

package/src/api/generated/ext_newsletter/_utils/fetchers/index.ts

@@ -0,0 +1,34 @@
+/**
+ * Typed Fetchers - Universal API functions
+ *
+ * Auto-generated from OpenAPI specification.
+ * These functions work in any JavaScript environment.
+ *
+ * Features:
+ * - Runtime validation with Zod
+ * - Type-safe parameters and responses
+ * - Works with any data-fetching library (SWR, React Query, etc)
+ * - Server Component compatible
+ *
+ * Usage:
+ * ```typescript
+ * import * as fetchers from './fetchers'
+ *
+ * // Direct usage
+ * const user = await fetchers.getUser(1)
+ *
+ * // With SWR
+ * const { data } = useSWR('user-1', () => fetchers.getUser(1))
+ *
+ * // With React Query
+ * const { data } = useQuery(['user', 1], () => fetchers.getUser(1))
+ * ```
+ */
+
+export * from './ext_newsletter__newsletter'
+export * from './ext_newsletter__newsletter__bulk_email'
+export * from './ext_newsletter__newsletter__campaigns'
+export * from './ext_newsletter__newsletter__logs'
+export * from './ext_newsletter__newsletter__newsletters'
+export * from './ext_newsletter__newsletter__subscriptions'
+export * from './ext_newsletter__newsletter__testing'

package/src/api/generated/ext_newsletter/_utils/hooks/ext_newsletter__newsletter.ts

@@ -0,0 +1,81 @@
+'use client';
+
+/**
+ * SWR Hooks for Newsletter
+ *
+ * React hooks powered by SWR for data fetching with automatic caching,
+ * revalidation, and optimistic updates.
+ *
+ * Usage:
+ * ```typescript
+ * // Query hooks (GET)
+ * const { data, error, isLoading } = useUsers({ page: 1 })
+ *
+ * // Mutation hooks (POST/PUT/PATCH/DELETE)
+ * const createUser = useCreateUser()
+ * await createUser({ name: 'John', email: 'john@example.com' })
+ * ```
+ */
+import { useSWRConfig } from 'swr'
+import * as Fetchers from '../fetchers/ext_newsletter__newsletter'
+import type { API } from '../../index'
+import type { NewsletterCampaign } from '../schemas/NewsletterCampaign.schema'
+import type { PatchedNewsletterCampaignRequest } from '../schemas/PatchedNewsletterCampaignRequest.schema'
+import type { PatchedUnsubscribeRequest } from '../schemas/PatchedUnsubscribeRequest.schema'
+import type { Unsubscribe } from '../schemas/Unsubscribe.schema'
+import type { UnsubscribeRequest } from '../schemas/UnsubscribeRequest.schema'
+
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/newsletter/campaigns/{id}/
+ */
+export function usePartialUpdateNewsletterCampaignsPartialUpdate() {
+  const { mutate } = useSWRConfig()
+
+  return async (id: number, data?: PatchedNewsletterCampaignRequest, client?: API): Promise<NewsletterCampaign> => {
+    const result = await Fetchers.partialUpdateNewsletterCampaignsPartialUpdate(id, data, client)
+    // Revalidate related queries
+    mutate('cfg-newsletter-campaigns-partial')
+    return result
+  }
+}
+
+
+/**
+ * API operation
+ *
+ * @method PUT
+ * @path /cfg/newsletter/unsubscribe/
+ */
+export function useUpdateNewsletterUnsubscribeUpdate() {
+  const { mutate } = useSWRConfig()
+
+  return async (data: UnsubscribeRequest, client?: API): Promise<Unsubscribe> => {
+    const result = await Fetchers.updateNewsletterUnsubscribeUpdate(data, client)
+    // Revalidate related queries
+    mutate('cfg-newsletter-unsubscribe')
+    return result
+  }
+}
+
+
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/newsletter/unsubscribe/
+ */
+export function usePartialUpdateNewsletterUnsubscribePartialUpdate() {
+  const { mutate } = useSWRConfig()
+
+  return async (data?: PatchedUnsubscribeRequest, client?: API): Promise<Unsubscribe> => {
+    const result = await Fetchers.partialUpdateNewsletterUnsubscribePartialUpdate(data, client)
+    // Revalidate related queries
+    mutate('cfg-newsletter-unsubscribe-partial')
+    return result
+  }
+}
+
+

package/src/api/generated/ext_newsletter/_utils/hooks/ext_newsletter__newsletter__bulk_email.ts

@@ -0,0 +1,42 @@
+'use client';
+
+/**
+ * SWR Hooks for Bulk Email
+ *
+ * React hooks powered by SWR for data fetching with automatic caching,
+ * revalidation, and optimistic updates.
+ *
+ * Usage:
+ * ```typescript
+ * // Query hooks (GET)
+ * const { data, error, isLoading } = useUsers({ page: 1 })
+ *
+ * // Mutation hooks (POST/PUT/PATCH/DELETE)
+ * const createUser = useCreateUser()
+ * await createUser({ name: 'John', email: 'john@example.com' })
+ * ```
+ */
+import { useSWRConfig } from 'swr'
+import * as Fetchers from '../fetchers/ext_newsletter__newsletter__bulk_email'
+import type { API } from '../../index'
+import type { BulkEmailRequest } from '../schemas/BulkEmailRequest.schema'
+import type { BulkEmailResponse } from '../schemas/BulkEmailResponse.schema'
+
+/**
+ * Send Bulk Email
+ *
+ * @method POST
+ * @path /cfg/newsletter/bulk/
+ */
+export function useCreateNewsletterBulkCreate() {
+  const { mutate } = useSWRConfig()
+
+  return async (data: BulkEmailRequest, client?: API): Promise<BulkEmailResponse> => {
+    const result = await Fetchers.createNewsletterBulkCreate(data, client)
+    // Revalidate related queries
+    mutate('cfg-newsletter-bulk')
+    return result
+  }
+}
+
+

package/src/api/generated/ext_newsletter/_utils/hooks/ext_newsletter__newsletter__campaigns.ts

@@ -0,0 +1,130 @@
+'use client';
+
+/**
+ * SWR Hooks for Campaigns
+ *
+ * React hooks powered by SWR for data fetching with automatic caching,
+ * revalidation, and optimistic updates.
+ *
+ * Usage:
+ * ```typescript
+ * // Query hooks (GET)
+ * const { data, error, isLoading } = useUsers({ page: 1 })
+ *
+ * // Mutation hooks (POST/PUT/PATCH/DELETE)
+ * const createUser = useCreateUser()
+ * await createUser({ name: 'John', email: 'john@example.com' })
+ * ```
+ */
+import useSWR from 'swr'
+import { useSWRConfig } from 'swr'
+import * as Fetchers from '../fetchers/ext_newsletter__newsletter__campaigns'
+import type { API } from '../../index'
+import type { NewsletterCampaign } from '../schemas/NewsletterCampaign.schema'
+import type { NewsletterCampaignRequest } from '../schemas/NewsletterCampaignRequest.schema'
+import type { PaginatedNewsletterCampaignList } from '../schemas/PaginatedNewsletterCampaignList.schema'
+import type { SendCampaignRequest } from '../schemas/SendCampaignRequest.schema'
+import type { SendCampaignResponse } from '../schemas/SendCampaignResponse.schema'
+
+/**
+ * List Newsletter Campaigns
+ *
+ * @method GET
+ * @path /cfg/newsletter/campaigns/
+ */
+export function useNewsletterCampaignsList(params?: { page?: number; page_size?: number }, client?: API): ReturnType<typeof useSWR<PaginatedNewsletterCampaignList>> {
+  return useSWR<PaginatedNewsletterCampaignList>(
+    params ? ['cfg-newsletter-campaigns', params] : 'cfg-newsletter-campaigns',
+    () => Fetchers.getNewsletterCampaignsList(params, client)
+  )
+}
+
+
+/**
+ * Create Newsletter Campaign
+ *
+ * @method POST
+ * @path /cfg/newsletter/campaigns/
+ */
+export function useCreateNewsletterCampaignsCreate() {
+  const { mutate } = useSWRConfig()
+
+  return async (data: NewsletterCampaignRequest, client?: API): Promise<NewsletterCampaign> => {
+    const result = await Fetchers.createNewsletterCampaignsCreate(data, client)
+    // Revalidate related queries
+    mutate('cfg-newsletter-campaigns')
+    return result
+  }
+}
+
+
+/**
+ * Get Campaign Details
+ *
+ * @method GET
+ * @path /cfg/newsletter/campaigns/{id}/
+ */
+export function useNewsletterCampaignsRetrieve(id: number, client?: API): ReturnType<typeof useSWR<NewsletterCampaign>> {
+  return useSWR<NewsletterCampaign>(
+    ['cfg-newsletter-campaign', id],
+    () => Fetchers.getNewsletterCampaignsRetrieve(id, client)
+  )
+}
+
+
+/**
+ * Update Campaign
+ *
+ * @method PUT
+ * @path /cfg/newsletter/campaigns/{id}/
+ */
+export function useUpdateNewsletterCampaignsUpdate() {
+  const { mutate } = useSWRConfig()
+
+  return async (id: number, data: NewsletterCampaignRequest, client?: API): Promise<NewsletterCampaign> => {
+    const result = await Fetchers.updateNewsletterCampaignsUpdate(id, data, client)
+    // Revalidate related queries
+    mutate('cfg-newsletter-campaigns')
+    mutate('cfg-newsletter-campaign')
+    return result
+  }
+}
+
+
+/**
+ * Delete Campaign
+ *
+ * @method DELETE
+ * @path /cfg/newsletter/campaigns/{id}/
+ */
+export function useDeleteNewsletterCampaignsDestroy() {
+  const { mutate } = useSWRConfig()
+
+  return async (id: number, client?: API): Promise<void> => {
+    const result = await Fetchers.deleteNewsletterCampaignsDestroy(id, client)
+    // Revalidate related queries
+    mutate('cfg-newsletter-campaigns')
+    mutate('cfg-newsletter-campaign')
+    return result
+  }
+}
+
+
+/**
+ * Send Newsletter Campaign
+ *
+ * @method POST
+ * @path /cfg/newsletter/campaigns/send/
+ */
+export function useCreateNewsletterCampaignsSendCreate() {
+  const { mutate } = useSWRConfig()
+
+  return async (data: SendCampaignRequest, client?: API): Promise<SendCampaignResponse> => {
+    const result = await Fetchers.createNewsletterCampaignsSendCreate(data, client)
+    // Revalidate related queries
+    mutate('cfg-newsletter-campaigns-send')
+    return result
+  }
+}
+
+

package/src/api/generated/ext_newsletter/_utils/hooks/ext_newsletter__newsletter__logs.ts

@@ -0,0 +1,37 @@
+'use client';
+
+/**
+ * SWR Hooks for Logs
+ *
+ * React hooks powered by SWR for data fetching with automatic caching,
+ * revalidation, and optimistic updates.
+ *
+ * Usage:
+ * ```typescript
+ * // Query hooks (GET)
+ * const { data, error, isLoading } = useUsers({ page: 1 })
+ *
+ * // Mutation hooks (POST/PUT/PATCH/DELETE)
+ * const createUser = useCreateUser()
+ * await createUser({ name: 'John', email: 'john@example.com' })
+ * ```
+ */
+import useSWR from 'swr'
+import * as Fetchers from '../fetchers/ext_newsletter__newsletter__logs'
+import type { API } from '../../index'
+import type { PaginatedEmailLogList } from '../schemas/PaginatedEmailLogList.schema'
+
+/**
+ * List Email Logs
+ *
+ * @method GET
+ * @path /cfg/newsletter/logs/
+ */
+export function useNewsletterLogsList(params?: { page?: number; page_size?: number }, client?: API): ReturnType<typeof useSWR<PaginatedEmailLogList>> {
+  return useSWR<PaginatedEmailLogList>(
+    params ? ['cfg-newsletter-logs', params] : 'cfg-newsletter-logs',
+    () => Fetchers.getNewsletterLogsList(params, client)
+  )
+}
+
+

package/src/api/generated/ext_newsletter/_utils/hooks/ext_newsletter__newsletter__newsletters.ts

@@ -0,0 +1,52 @@
+'use client';
+
+/**
+ * SWR Hooks for Newsletters
+ *
+ * React hooks powered by SWR for data fetching with automatic caching,
+ * revalidation, and optimistic updates.
+ *
+ * Usage:
+ * ```typescript
+ * // Query hooks (GET)
+ * const { data, error, isLoading } = useUsers({ page: 1 })
+ *
+ * // Mutation hooks (POST/PUT/PATCH/DELETE)
+ * const createUser = useCreateUser()
+ * await createUser({ name: 'John', email: 'john@example.com' })
+ * ```
+ */
+import useSWR from 'swr'
+import * as Fetchers from '../fetchers/ext_newsletter__newsletter__newsletters'
+import type { API } from '../../index'
+import type { Newsletter } from '../schemas/Newsletter.schema'
+import type { PaginatedNewsletterList } from '../schemas/PaginatedNewsletterList.schema'
+
+/**
+ * List Active Newsletters
+ *
+ * @method GET
+ * @path /cfg/newsletter/newsletters/
+ */
+export function useNewsletterNewslettersList(params?: { page?: number; page_size?: number }, client?: API): ReturnType<typeof useSWR<PaginatedNewsletterList>> {
+  return useSWR<PaginatedNewsletterList>(
+    params ? ['cfg-newsletter-newsletters', params] : 'cfg-newsletter-newsletters',
+    () => Fetchers.getNewsletterNewslettersList(params, client)
+  )
+}
+
+
+/**
+ * Get Newsletter Details
+ *
+ * @method GET
+ * @path /cfg/newsletter/newsletters/{id}/
+ */
+export function useNewsletterNewslettersRetrieve(id: number, client?: API): ReturnType<typeof useSWR<Newsletter>> {
+  return useSWR<Newsletter>(
+    ['cfg-newsletter-newsletter', id],
+    () => Fetchers.getNewsletterNewslettersRetrieve(id, client)
+  )
+}
+
+