Type Safety

import { Paystack } from '@efobi/paystack';

const paystack = new Paystack('sk_test_...');

// TypeScript knows the exact shape of input and output
const result = await paystack.transaction.initialize({
  email: 'customer@example.com',  // string (validated as email)
  amount: '50000',                 // string (required)
  currency: 'NGN',                 // 'NGN' | 'USD' | 'GHS' | 'ZAR' | 'KES' | 'XOF'
  reference: 'ref_123',            // string (optional)
  callback_url: 'https://...',     // string (validated as URL, optional)
  metadata: { userId: 123 }        // any (optional)
});

// TypeScript knows result has 'data' and 'error' properties
if (result.data) {
  const url = result.data.data.authorization_url; // string
  const code = result.data.data.access_code;      // string
  const ref = result.data.data.reference;         // string
}

paystack.transaction.  // IDE shows: initialize, verify, list, getTransactionById, etc.

paystack.transaction.initialize({
  email: '',  // IDE suggests: string (email format)
  amount: '', // IDE suggests: string (required)
  // Press Ctrl+Space to see all available options
});

// ❌ TypeScript Error: Type 'number' is not assignable to type 'string'
const result = await paystack.transaction.initialize({
  email: 'customer@example.com',
  amount: 50000  // Should be a string: '50000'
});

// ❌ TypeScript Error: Property 'invalid' does not exist
const result = await paystack.transaction.initialize({
  email: 'customer@example.com',
  amount: '50000',
  invalid: true  // Unknown property
});

// ✅ Correct
const result = await paystack.transaction.initialize({
  email: 'customer@example.com',
  amount: '50000'
});

const result = await paystack.transaction.initialize({
  email: 'not-an-email',  // ❌ Will fail Zod validation
  amount: '50000'
});

if (result.error) {
  console.log(result.error.issues);
  // [
  //   {
  //     validation: 'email',
  //     code: 'invalid_string',
  //     message: 'Invalid email',
  //     path: ['email']
  //   }
  // ]
}

import type { 
  TxnInitializeInput,
  TxnInitializeSuccess,
  TxnVerifySuccess,
  TransactionShared
} from '@efobi/paystack/transaction';

// Use types in your code
function createTransaction(data: TxnInitializeInput) {
  return paystack.transaction.initialize(data);
}

function handleSuccess(response: TxnInitializeSuccess) {
  const { authorization_url, access_code, reference } = response.data;
  // TypeScript knows these properties exist
}

import type { Currency, Customer, Authorization } from '@efobi/paystack';

interface PaymentData {
  currency: Currency;        // 'NGN' | 'USD' | 'GHS' | 'ZAR' | 'KES' | 'XOF'
  customer: Customer;        // Full customer object
  authorization: Authorization; // Card authorization details
}

const result = await paystack.transaction.initialize({
  email: 'customer@example.com',
  amount: '50000',
  currency: 'NGN'  // ✅ Valid
  // currency: 'EUR'  // ❌ TypeScript error: Type '"EUR"' is not assignable to type Currency
});

email: z.email()  // Validates RFC 5322 email format

// ✅ Valid emails
const emails = [
  'user@example.com',
  'first.last@company.co.uk',
  'name+tag@domain.com'
];

// ❌ Invalid emails
const invalid = [
  'not-an-email',
  '@example.com',
  'user@',
  'user @example.com'
];

callback_url: z.url().optional()

// ✅ Valid URLs
const urls = [
  'https://example.com/callback',
  'https://app.example.com/api/webhook',
  'http://localhost:3000/callback'
];

// ❌ Invalid URLs
const invalid = [
  'not-a-url',
  'example.com',  // Missing protocol
  '/callback'     // Relative URL
];

type PaystackResult<T> = 
  | { data: T; error: undefined }
  | { data: undefined; error: ZodError };

function processResult<T>(result: PaystackResult<T>): T {
  if (result.error) {
    throw new Error('Validation failed');
  }
  return result.data;  // TypeScript knows this is T, not undefined
}

import type { Paystack } from '@efobi/paystack';

type ExtractData<T> = T extends { data: infer D } ? D : never;

type TransactionData = ExtractData<
  Awaited<ReturnType<Paystack['transaction']['initialize']>>
>;
// TransactionData is the success response type

import type { TxnInitializeInput } from '@efobi/paystack/transaction';

// Make all fields required
type RequiredTransaction = Required<TxnInitializeInput>;

// Pick specific fields
type MinimalTransaction = Pick<TxnInitializeInput, 'email' | 'amount'>;

// Omit fields
type TransactionWithoutMetadata = Omit<TxnInitializeInput, 'metadata'>;

// Make all fields optional
type PartialTransaction = Partial<TxnInitializeInput>;

import { z } from 'zod';
import type { TxnInitializeInput } from '@efobi/paystack/transaction';

// Extend the base schema
const customTransactionInput = z.object({
  // Add your custom fields
  userId: z.string(),
  sessionId: z.string().optional(),
});

type CustomTransaction = TxnInitializeInput & z.infer<typeof customTransactionInput>;

function initializeWithTracking(data: CustomTransaction) {
  const { userId, sessionId, ...paystackData } = data;
  
  // Track in your system
  trackTransaction(userId, sessionId);
  
  // Initialize with Paystack
  return paystack.transaction.initialize(paystackData);
}

import { z } from 'zod';

const userInput = getUserInput(); // Unknown data

const schema = z.object({
  email: z.email(),
  amount: z.string()
});

const result = schema.safeParse(userInput);

if (result.success) {
  // Data is validated and typed
  await paystack.transaction.initialize(result.data);
} else {
  // Handle validation errors
  console.error(result.error.issues);
}