[PERS SDK - v2.3.26](/sdk-reference/readme) / [Exports](/sdk-reference/modules) / RedemptionManager

# Class: RedemptionManager

Redemption Manager - Clean, high-level interface for redemption operations

Provides a comprehensive API for loyalty redemption management including discovering
available rewards, redeeming offers, tracking redemption history, and administrative
redemption lifecycle operations. Redemptions convert loyalty tokens into valuable
rewards, discounts, and benefits for users in the loyalty ecosystem.

**`Example`**

```typescript
// Browse available redemption offers
const { data: offers } = await sdk.redemptions.getRedemptions();
console.log(`${offers.length} redemption offers available`);

// Redeem a specific offer
const redemptionResult = await sdk.redemptions.redeem('discount-10-percent');
console.log('Redemption successful:', redemptionResult.success);

// Check redemption history
const { data: history } = await sdk.redemptions.getUserRedemptions();
console.log(`You have redeemed ${history.length} offers`);
```

**`Example`**

```typescript
// Get available redemption types/categories
const types = await sdk.redemptions.getRedemptionTypes();

// Browse offers by category
const discounts = offers.filter(offer => 
  offer.redemptionType?.name?.includes('Discount')
);

const products = offers.filter(offer => 
  offer.redemptionType?.name?.includes('Product')
);

console.log(`${discounts.length} discounts, ${products.length} products available`);
```

**`Example`**

```typescript
// Admin: Create new redemption offer
const newOffer = await sdk.redemptions.createRedemption({
  title: 'Free Coffee Voucher',
  description: 'Redeem for one free coffee at partner cafes',
  redemptionTypeId: 'voucher-type-id',
  isActive: true
});

// Admin: Set redemption cost
await sdk.redemptions.createRedemptionTokenUnit(newOffer.id, {
  tokenId: 'loyalty-points',
  amount: 250,
  type: 'COST'
});
```

## Table of contents

### Constructors

- [constructor](/sdk-reference/classes/redemptionmanager#constructor)


### Methods

- [getRedemptions](/sdk-reference/classes/redemptionmanager#getredemptions)
- [getRedemptionById](/sdk-reference/classes/redemptionmanager#getredemptionbyid)
- [getRedemptionTypes](/sdk-reference/classes/redemptionmanager#getredemptiontypes)
- [redeem](/sdk-reference/classes/redemptionmanager#redeem)
- [getUserRedemptions](/sdk-reference/classes/redemptionmanager#getuserredemptions)
- [getRedemptionRedeems](/sdk-reference/classes/redemptionmanager#getredemptionredeems)
- [createRedemption](/sdk-reference/classes/redemptionmanager#createredemption)
- [updateRedemption](/sdk-reference/classes/redemptionmanager#updateredemption)
- [toggleRedemptionStatus](/sdk-reference/classes/redemptionmanager#toggleredemptionstatus)
- [createRedemptionTokenUnit](/sdk-reference/classes/redemptionmanager#createredemptiontokenunit)
- [deleteRedemptionTokenUnit](/sdk-reference/classes/redemptionmanager#deleteredemptiontokenunit)
- [createRedemptionType](/sdk-reference/classes/redemptionmanager#createredemptiontype)
- [updateRedemptionType](/sdk-reference/classes/redemptionmanager#updateredemptiontype)
- [deleteRedemptionType](/sdk-reference/classes/redemptionmanager#deleteredemptiontype)
- [deleteRedemption](/sdk-reference/classes/redemptionmanager#deleteredemption)
- [exportCSV](/sdk-reference/classes/redemptionmanager#exportcsv)
- [exportRedeemsCSV](/sdk-reference/classes/redemptionmanager#exportredeemscsv)
- [getRedemptionService](/sdk-reference/classes/redemptionmanager#getredemptionservice)
- [setRedemptionApproval](/sdk-reference/classes/redemptionmanager#setredemptionapproval)


## Constructors

### constructor

• **new RedemptionManager**(`apiClient`, `events?`): [`RedemptionManager`](/sdk-reference/classes/redemptionmanager)

#### Parameters

| Name | Type |
|  --- | --- |
| `apiClient` | [`PersApiClient`](/sdk-reference/classes/persapiclient) |
| `events?` | [`PersEventEmitter`](/sdk-reference/classes/perseventemitter) |


#### Returns

[`RedemptionManager`](/sdk-reference/classes/redemptionmanager)

#### Defined in

[managers/redemption-manager.ts:81](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L81)

## Methods

### getRedemptions

▸ **getRedemptions**(`options?`): `Promise`<`PaginatedResponseDTO`<`RedemptionDTO`>>

Get redemption offers

Retrieves redemption offers based on user permissions and optional filters.
The results returned depend on the authenticated user's role:

**Regular Users:** See only active redemption offers available for purchase
**Administrators:** Can see all redemptions and filter by active/inactive status

Active redemptions include discounts, vouchers, products, and services that
can be purchased using loyalty tokens. The backend automatically enforces
permission-based filtering.

#### Parameters

| Name | Type | Description |
|  --- | --- | --- |
| `options?` | `RedemptionQueryParams` | Optional filters and pagination: - `active`: Filter by active status (true/false). Admins only - regular users always see active offers - `search`: Free text search across name, description, tags (case-insensitive) - Pagination options: `page`, `limit`, `sortBy`, `sortOrder` |


#### Returns

`Promise`<`PaginatedResponseDTO`<`RedemptionDTO`>>

Promise resolving to paginated redemption offers

**`Example`**

```typescript
// Regular users automatically see only active offers
const { data: offers, pagination } = await sdk.redemptions.getRedemptions();

console.log('Available Redemption Offers:');
console.log(`Showing ${offers.length} of ${pagination.total} offers`);

offers.forEach(offer => {
  console.log(`\n${offer.name}`);
  console.log(`${offer.description}`);
  console.log(`Type: ${offer.type?.name || 'General'}`);
  
  if (offer.tokenUnits?.length) {
    console.log('Cost:');
    offer.tokenUnits.forEach(unit => {
      console.log(`   ${unit.amount} ${unit.token.symbol}`);
    });
  }
  
  if (offer.availableQuantity !== undefined) {
    console.log(`Available: ${offer.availableQuantity}`);
  }
});

// Filter offers by affordability
const userBalance = 1000;
const affordableOffers = offers.filter(offer => 
  offer.tokenUnits?.every(unit => unit.amount <= userBalance)
);

console.log(`\n${affordableOffers.length} offers within your budget`);
```

**`Example`**

```typescript
// Search by text (matches name, description, tags)
const { data: coffeeOffers } = await sdk.redemptions.getRedemptions({ 
  search: 'coffee' 
});

console.log(`Found ${coffeeOffers.length} coffee-related offers`);

// Search with sorting
const { data: sortedResults } = await sdk.redemptions.getRedemptions({ 
  search: 'discount',
  sortBy: 'name',
  sortOrder: 'ASC'
});
```

**`Example`**

```typescript
// Admins can see all redemptions and filter by status
const { data: allRedemptions } = await sdk.redemptions.getRedemptions();
const { data: activeOnly } = await sdk.redemptions.getRedemptions({ active: true });
const { data: inactiveOnly } = await sdk.redemptions.getRedemptions({ active: false });

console.log('Redemption Inventory:');
console.log(`Total offers: ${allRedemptions.length}`);
console.log(`Active offers: ${activeOnly.length}`);
console.log(`Inactive offers: ${inactiveOnly.length}`);

// Search inactive redemptions
const { data: inactiveVouchers } = await sdk.redemptions.getRedemptions({
  active: false,
  search: 'voucher'
});
```

**`Example`**

```typescript
// Load first page
const { data: firstPage, pagination } = await sdk.redemptions.getRedemptions({ 
  page: 1, 
  limit: 10 
});

console.log(`Page ${pagination.page} of ${pagination.totalPages}`);
console.log(`${firstPage.length} offers on this page`);

// Load next page if available
if (pagination.hasNextPage) {
  const { data: nextPage } = await sdk.redemptions.getRedemptions({ 
    page: pagination.page + 1,
    limit: 10
  });
}
```

#### Defined in

[managers/redemption-manager.ts:198](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L198)

### getRedemptionById

▸ **getRedemptionById**(`id`, `include?`): `Promise`<`RedemptionDTO`>

Get a specific redemption by ID

Retrieves detailed information about a specific redemption offer.
Useful when you already have the redemption ID and need full details.

#### Parameters

| Name | Type | Description |
|  --- | --- | --- |
| `id` | `string` | Redemption UUID |
| `include?` | `RedemptionIncludeRelation`[] | Optional relations to include: 'redeemCount' |


#### Returns

`Promise`<`RedemptionDTO`>

Promise resolving to the redemption

**`Example`**

```typescript
const redemption = await sdk.redemptions.getRedemptionById('7baf4d39-0bd6-45ca-9c66-8c0d655767c3');
console.log(redemption.name);
console.log(redemption.description);
```

**`Example`**

```typescript
const redemption = await sdk.redemptions.getRedemptionById(
  'redemption-123', 
  ['redeemCount']
);
console.log(`${redemption.name} has been redeemed ${redemption.redeemCount} times`);
```

**`Example`**

```typescript
const redemption = await sdk.redemptions.getRedemptionById(id);

console.log('Redemption Details:');
console.log(`Name: ${redemption.name}`);
console.log(`Description: ${redemption.description}`);
console.log(`Active: ${redemption.isActive}`);

if (redemption.tokenUnits?.length) {
  console.log('Cost:');
  redemption.tokenUnits.forEach(unit => {
    console.log(`  ${unit.amount} ${unit.token.symbol}`);
  });
}
```

#### Defined in

[managers/redemption-manager.ts:245](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L245)

### getRedemptionTypes

▸ **getRedemptionTypes**(`options?`): `Promise`<`PaginatedResponseDTO`<`RedemptionTypeDTO`>>

Get available redemption types

Retrieves all redemption type categories that classify different kinds of
rewards and offers. Types help users navigate and filter redemption options
based on their preferences and needs.

#### Parameters

| Name | Type |
|  --- | --- |
| `options?` | `PaginationOptions` |


#### Returns

`Promise`<`PaginatedResponseDTO`<`RedemptionTypeDTO`>>

Promise resolving to paginated redemption type definitions

**`Example`**

```typescript
const { data: redemptionTypes } = await sdk.redemptions.getRedemptionTypes();

console.log('Redemption Categories:');
redemptionTypes.forEach(type => {
  console.log(`- ${type.name}: ${type.description}`);
});

// Use for filtering UI
const typeFilter = redemptionTypes.map(type => ({
  id: type.id,
  label: type.name,
  description: type.description
}));

// Find specific redemption types
const discountType = redemptionTypes.find(t => 
  t.name.toLowerCase().includes('discount')
);
const voucherType = redemptionTypes.find(t => 
  t.name.toLowerCase().includes('voucher')
);
```

#### Defined in

[managers/redemption-manager.ts:283](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L283)

### redeem

▸ **redeem**(`request`, `context?`): `Promise`<`RedemptionRedeemRequestResponseDTO`>

Redeem a redemption offer

Executes the redemption of a specific offer for the authenticated user.
This action validates eligibility, deducts required tokens, and provides
redemption confirmation details. Creates a permanent redemption record
and may generate voucher codes or instructions.

Supports dynamic context for personalized NFT generation when the redemption
issues ERC721 tokens. Context can include validity dates, AI prompt placeholders,
and custom metadata.

#### Parameters

| Name | Type | Description |
|  --- | --- | --- |
| `request` | `string` | `RedemptionRedeemRequestDTO` | Redemption ID string, or a full `RedemptionRedeemRequestDTO` object (supports `redemptionId`, `businessId`, and `context` fields) |
| `context?` | `DynamicContext` | Optional dynamic context when passing a plain `redemptionId` string |


#### Returns

`Promise`<`RedemptionRedeemRequestResponseDTO`>

Promise resolving to redemption result with confirmation details

**`Throws`**

When redemption is not available or user lacks required tokens

**`Example`**

```typescript
try {
  const result = await sdk.redemptions.redeem('coffee-voucher-123');
  
  if (result.success) {
    console.log('Redemption Successful!');
    console.log('Confirmation ID:', result.id);
    console.log('Redeemed at:', result.redeemedAt);
    
    // Display redemption details
    if (result.voucherCode) {
      console.log('Voucher Code:', result.voucherCode);
      console.log('Present this code to redeem your reward');
    }
    
    if (result.instructions) {
      console.log('Instructions:', result.instructions);
    }
    
    // Show tokens deducted
    if (result.tokensUsed?.length) {
      console.log('\nTokens Used:');
      result.tokensUsed.forEach(token => {
        console.log(`- ${token.amount} ${token.symbol}`);
      });
    }
    
  } else {
    console.log('Redemption failed:', result.error);
  }
  
} catch (error) {
  console.log('Redemption error:', error.message);
  
  // Handle specific error cases
  if (error.message.includes('insufficient')) {
    console.log('You need more loyalty points for this redemption');
  } else if (error.message.includes('unavailable')) {
    console.log('This offer is no longer available');
  }
}
```

**`Example`**

```typescript
// Event ticket with dynamic validity and personalization
const result = await sdk.redemptions.redeem('event-ticket-123', {
  // Validity - token valid for event duration + 2 hours
  validityDate: new Date().toISOString(),
  validityDuration: 8,  // 8 hours
  
  // AI prompt context - available as {{context.xxx}} in prompts
  attendeeName: 'John Doe',
  ticketTier: 'VIP',
  seatSection: 'A12',
});

// Hotel stay NFT with check-in/check-out dates
const hotelResult = await sdk.redemptions.redeem('hotel-nft-456', {
  validityDate: '2026-04-15T14:00:00Z',      // Check-in
  validityEndDate: '2026-04-20T11:00:00Z',   // Check-out
  guestName: 'Jane Smith',
  roomNumber: '305',
  roomType: 'Suite',
});
```

**`Example`**

```typescript
// Get offer details first
const { data: offers } = await sdk.redemptions.getRedemptions();
const targetOffer = offers.find(o => o.id === 'premium-discount');

if (targetOffer) {
  // Check if user can afford the redemption
  const userTokens = await sdk.users.getUserTokenBalances();
  const canAfford = targetOffer.tokenUnits?.every(unit => {
    const userBalance = userTokens.find(t => t.tokenId === unit.tokenId);
    return userBalance && userBalance.amount >= unit.amount;
  });
  
  if (canAfford) {
    const result = await sdk.redemptions.redeem(targetOffer.id);
    console.log('Redemption processed:', result.success);
  } else {
    console.log('Insufficient tokens for this redemption');
  }
}
```

#### Defined in

[managers/redemption-manager.ts:396](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L396)

### getUserRedemptions

▸ **getUserRedemptions**(`filters?`, `options?`, `include?`): `Promise`<`PaginatedResponseDTO`<`RedemptionRedeemDTO`>>

Get user's redemption history

Retrieves all redemptions that the authenticated user has successfully
completed. Includes redemption details, timestamps, voucher codes, and
token usage. Useful for user account history and support purposes.

#### Parameters

| Name | Type |
|  --- | --- |
| `filters?` | `Object` |
| `filters.redemptionId?` | `string` |
| `filters.status?` | `ProcessRecordStatus` |
| `options?` | `PaginationOptions` |
| `include?` | `RedemptionRedeemIncludeRelation`[] |


#### Returns

`Promise`<`PaginatedResponseDTO`<`RedemptionRedeemDTO`>>

Promise resolving to paginated user redemption records

**`Example`**

```typescript
const { data: userRedemptions, pagination } = await sdk.redemptions.getUserRedemptions();

console.log(`Redemption History (${userRedemptions.length} of ${pagination.total} items):`);

userRedemptions.forEach((redemption, index) => {
  console.log(`\n${index + 1}. ${redemption.redemption.name}`);
  console.log(`   Date: ${new Date(redemption.redeemedAt).toLocaleDateString()}`);
  console.log(`   Type: ${redemption.redemption.type?.name || 'General'}`);
  
  if (redemption.voucherCode) {
    console.log(`   Voucher: ${redemption.voucherCode}`);
  }
  
  if (redemption.tokensUsed?.length) {
    console.log(`   Cost:`);
    redemption.tokensUsed.forEach(token => {
      console.log(`      ${token.amount} ${token.symbol}`);
    });
  }
  
  // Show status if available
  if (redemption.status) {
    console.log(`   Status: ${redemption.status}`);
  }
});

// Calculate redemption statistics
const totalRedemptions = userRedemptions.length;
const recentRedemptions = userRedemptions.filter(r => 
  new Date(r.redeemedAt) > new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
).length;

console.log(`\nStatistics:`);
console.log(`Total redemptions: ${totalRedemptions}`);
console.log(`This month: ${recentRedemptions}`);

// Group by redemption type
const byType = userRedemptions.reduce((acc, r) => {
  const type = r.redemption.redemptionType?.name || 'Other';
  acc[type] = (acc[type] || 0) + 1;
  return acc;
}, {});

console.log(`\nBy category:`);
Object.entries(byType).forEach(([type, count]) => {
  console.log(`${type}: ${count} redemptions`);
});
```

**`Example`**

```typescript
import { ProcessRecordStatus } from '@explorins/pers-sdk';

// Get only completed redemptions
const { data: completed } = await sdk.redemptions.getUserRedemptions(
  { status: ProcessRecordStatus.COMPLETED }
);
```

#### Defined in

[managers/redemption-manager.ts:483](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L483)

### getRedemptionRedeems

▸ **getRedemptionRedeems**(`filters?`, `include?`): `Promise`<`PaginatedResponseDTO`<`RedemptionRedeemDTO`>>

Admin: Get all redemption redeems with filtering and enriched data

Retrieves all redemption redeems across the platform with filtering capabilities.
This is an admin-level operation that allows monitoring and analytics of redemption
activity. Supports filtering by user, redemption offer, date range, and enrichment of related entities.

#### Parameters

| Name | Type | Description |
|  --- | --- | --- |
| `filters?` | `RedemptionRedeemQueryParams` | Filter options (userId, redemptionId, businessId, status, dateFrom, dateTo, pagination) |
| `include?` | `RedemptionRedeemIncludeRelation`[] | Optional relations to include for enrichment |


#### Returns

`Promise`<`PaginatedResponseDTO`<`RedemptionRedeemDTO`>>

Promise resolving to paginated list of redemption redeems

**`Throws`**

When not authenticated as admin

**`Example`**

```typescript
// Admin operation - get all redemption redeems
const { data: allRedeems, pagination } = await sdk.redemptions.getRedemptionRedeems();

console.log(`Total redeems: ${pagination.total}`);
console.log(`Page ${pagination.page} of ${pagination.pages}`);
```

**`Example`**

```typescript
// Get redeems for specific user
const { data: userRedeems } = await sdk.redemptions.getRedemptionRedeems({
  userId: 'user-123',
  limit: 50
});

console.log(`User has ${userRedeems.length} redemptions`);
```

**`Example`**

```typescript
// Get redeems within a specific date range
const { data: recentRedeems } = await sdk.redemptions.getRedemptionRedeems({
  dateFrom: new Date('2024-01-01'),
  dateTo: new Date('2024-01-31'),
  limit: 100
});

console.log(`${recentRedeems.length} redeems in January 2024`);
```

**`Example`**

```typescript
const { data: redeems } = await sdk.redemptions.getRedemptionRedeems(
  { page: 1, limit: 20 },
  ['redemption', 'user', 'business']
);

redeems.forEach(redeem => {
  const redemptionName = redeem.included?.redemption?.name || 'Unknown';
  const userEmail = redeem.included?.user?.email || redeem.userId;
  console.log(`${redemptionName} - ${userEmail}`);
});
```

#### Defined in

[managers/redemption-manager.ts:559](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L559)

### createRedemption

▸ **createRedemption**(`redemptionData`): `Promise`<`RedemptionDTO`>

Admin: Create new redemption offer

Creates a new redemption offer in the loyalty system. This operation requires
administrator privileges and establishes a new reward option that users can
purchase with their loyalty tokens.

#### Parameters

| Name | Type | Description |
|  --- | --- | --- |
| `redemptionData` | `RedemptionCreateRequestDTO` | Redemption configuration including title, description, and settings |


#### Returns

`Promise`<`RedemptionDTO`>

Promise resolving to created redemption offer

**`Throws`**

When not authenticated as admin or validation fails

**`Example`**

```typescript
// Admin operation - create discount redemption
const newRedemption = await sdk.redemptions.createRedemption({
  name: '20% Off Weekend Stay',
  description: 'Get 20% off your next weekend booking at partner hotels',
  redemptionTypeId: 'discount-type-id',
  isActive: true,
  availableQuantity: 100,
  validFrom: '2024-06-01T00:00:00Z',
  validUntil: '2024-08-31T23:59:59Z'
});

console.log('New redemption created:', newRedemption.name);
console.log('Redemption ID:', newRedemption.id);

// Set redemption cost
await sdk.redemptions.createRedemptionTokenUnit(newRedemption.id, {
  tokenId: 'loyalty-points',
  amount: 750,
  type: 'COST'
});

console.log('Cost set: 750 loyalty points');
```

#### Defined in

[managers/redemption-manager.ts:603](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L603)

### updateRedemption

▸ **updateRedemption**(`redemptionId`, `redemptionData`): `Promise`<`RedemptionDTO`>

Admin: Update redemption

Updates an existing redemption offer's configuration, availability, or
description. This operation requires administrator privileges and can modify
most redemption properties while preserving existing redemption history.

#### Parameters

| Name | Type | Description |
|  --- | --- | --- |
| `redemptionId` | `string` | ID of the redemption to update |
| `redemptionData` | `RedemptionCreateRequestDTO` | Updated redemption configuration |


#### Returns

`Promise`<`RedemptionDTO`>

Promise resolving to updated redemption offer

**`Throws`**

When not authenticated as admin or redemption not found

**`Example`**

```typescript
// Admin operation - update redemption details
const updated = await sdk.redemptions.updateRedemption('weekend-discount', {
  name: '25% Off Weekend Stay - Extended!',
  description: 'Enhanced discount - now 25% off weekend bookings',
  availableQuantity: 150,  // Increased availability
  validUntil: '2024-09-30T23:59:59Z'  // Extended validity
});

console.log('Redemption updated:', updated.name);
console.log('New quantity available:', updated.availableQuantity);
```

#### Defined in

[managers/redemption-manager.ts:633](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L633)

### toggleRedemptionStatus

▸ **toggleRedemptionStatus**(`redemptionId`): `Promise`<`RedemptionDTO`>

Admin: Toggle redemption active status

Toggles the active/inactive status of a redemption offer. Inactive redemptions
are not available for new purchases but existing redemptions remain valid.
Requires administrator privileges.

#### Parameters

| Name | Type | Description |
|  --- | --- | --- |
| `redemptionId` | `string` | ID of the redemption to toggle |


#### Returns

`Promise`<`RedemptionDTO`>

Promise resolving to updated redemption offer

**`Throws`**

When not authenticated as admin or redemption not found

**`Example`**

```typescript
// Admin operation - temporarily disable redemption
const updated = await sdk.redemptions.toggleRedemptionStatus('seasonal-offer');

console.log(`Redemption ${updated.isActive ? 'activated' : 'deactivated'}`);
console.log('Status:', updated.isActive ? 'Available' : 'Unavailable');

// Reactivate when ready
if (!updated.isActive) {
  console.log('Use the same method to reactivate when ready');
}
```

#### Defined in

[managers/redemption-manager.ts:662](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L662)

### createRedemptionTokenUnit

▸ **createRedemptionTokenUnit**(`redemptionId`, `tokenUnit`): `Promise`<`RedemptionDTO`>

Admin: Create redemption token unit

Adds a token cost requirement to a redemption offer, specifying the type
and amount of loyalty tokens needed to redeem the offer. Multiple token
units can be added to create complex pricing structures. Requires
administrator privileges.

#### Parameters

| Name | Type | Description |
|  --- | --- | --- |
| `redemptionId` | `string` | ID of the redemption |
| `tokenUnit` | `TokenUnitCreateRequestDTO` | Token unit configuration including token type and amount |


#### Returns

`Promise`<`RedemptionDTO`>

Promise resolving to updated redemption offer

**`Throws`**

When not authenticated as admin or validation fails

**`Example`**

```typescript
// Admin operation - set redemption cost
const updated = await sdk.redemptions.createRedemptionTokenUnit('premium-voucher', {
  tokenId: 'loyalty-points',
  amount: 1500,
  type: 'COST'
});

console.log('Token cost added to redemption');
console.log('Cost: 1500 loyalty points');
console.log('Total cost units:', updated.tokenUnits?.length);

// Add additional cost type (e.g., premium currency)
await sdk.redemptions.createRedemptionTokenUnit('premium-voucher', {
  tokenId: 'premium-credits',
  amount: 50,
  type: 'ADDITIONAL_COST'
});
```

#### Defined in

[managers/redemption-manager.ts:700](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L700)

### deleteRedemptionTokenUnit

▸ **deleteRedemptionTokenUnit**(`redemptionId`, `tokenUnitId`): `Promise`<`RedemptionDTO`>

Admin: Delete redemption token unit

Removes a token cost requirement from a redemption offer. This affects
the pricing of future redemptions but does not impact already completed
redemptions. Requires administrator privileges.

#### Parameters

| Name | Type | Description |
|  --- | --- | --- |
| `redemptionId` | `string` | ID of the redemption |
| `tokenUnitId` | `string` | ID of the token unit to remove |


#### Returns

`Promise`<`RedemptionDTO`>

Promise resolving to updated redemption offer

**`Throws`**

When not authenticated as admin or entities not found

**`Example`**

```typescript
// Admin operation - remove token cost from redemption
const updated = await sdk.redemptions.deleteRedemptionTokenUnit(
  'special-offer',
  'token-unit-123'
);

console.log('Token cost removed from redemption');
console.log('Remaining cost units:', updated.tokenUnits?.length);
```

#### Defined in

[managers/redemption-manager.ts:728](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L728)

### createRedemptionType

▸ **createRedemptionType**(`data`): `Promise`<`RedemptionTypeDTO`>

Admin: Create redemption type

Creates a new redemption type category for organizing redemption offers.
Requires administrator privileges.

#### Parameters

| Name | Type | Description |
|  --- | --- | --- |
| `data` | `RedemptionTypeCreateRequestDTO` | Redemption type data (name, description, imageUrl) |


#### Returns

`Promise`<`RedemptionTypeDTO`>

Promise resolving to created redemption type

**`Throws`**

When not authenticated as admin or validation fails

**`Example`**

```typescript
const newType = await sdk.redemptions.createRedemptionType({
  name: 'Premium Rewards',
  description: 'High-value exclusive rewards',
  imageUrl: 'https://example.com/premium-icon.png'
});

console.log('Created type:', newType.name);
```

#### Defined in

[managers/redemption-manager.ts:757](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L757)

### updateRedemptionType

▸ **updateRedemptionType**(`data`): `Promise`<`RedemptionTypeDTO`>

Admin: Update redemption type

Updates an existing redemption type's properties.
Requires administrator privileges.

#### Parameters

| Name | Type | Description |
|  --- | --- | --- |
| `data` | `RedemptionTypeDTO` | Updated redemption type data (must include id) |


#### Returns

`Promise`<`RedemptionTypeDTO`>

Promise resolving to updated redemption type

**`Throws`**

When not authenticated as admin or type not found

**`Example`**

```typescript
const updated = await sdk.redemptions.updateRedemptionType({
  id: 123,
  name: 'VIP Rewards',
  description: 'Updated description',
  imageUrl: 'https://example.com/vip-icon.png'
});

console.log('Updated type:', updated.name);
```

#### Defined in

[managers/redemption-manager.ts:783](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L783)

### deleteRedemptionType

▸ **deleteRedemptionType**(`id`): `Promise`<`boolean`>

Admin: Delete redemption type

Deletes a redemption type. Will fail if type is in use by redemptions.
Requires administrator privileges.

#### Parameters

| Name | Type | Description |
|  --- | --- | --- |
| `id` | `number` | Redemption type ID to delete |


#### Returns

`Promise`<`boolean`>

Promise resolving to true if deleted successfully

**`Throws`**

When not authenticated as admin or type not found/in use

**`Example`**

```typescript
const success = await sdk.redemptions.deleteRedemptionType(123);
console.log('Deleted:', success);
```

#### Defined in

[managers/redemption-manager.ts:803](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L803)

### deleteRedemption

▸ **deleteRedemption**(`id`): `Promise`<`boolean`>

Delete a redemption (soft delete)

#### Parameters

| Name | Type | Description |
|  --- | --- | --- |
| `id` | `string` | Redemption ID to delete |


#### Returns

`Promise`<`boolean`>

Promise resolving to true if deleted successfully

**`Example`**

```typescript
const success = await sdk.redemptions.deleteRedemption('redemption-123');
console.log('Deleted:', success);
```

#### Defined in

[managers/redemption-manager.ts:819](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L819)

### exportCSV

▸ **exportCSV**(`options?`): `Promise`<`Blob`>

Admin: Export redemptions as CSV

Generates a comprehensive CSV export of all tenant redemptions for
external analysis, reporting, or compliance purposes. This operation
requires administrator privileges and creates a downloadable file.

#### Parameters

| Name | Type | Description |
|  --- | --- | --- |
| `options?` | `Object` | Optional date range filters |
| `options.dateFrom?` | `string` | Start date filter (ISO date string) |
| `options.dateTo?` | `string` | End date filter (ISO date string) |


#### Returns

`Promise`<`Blob`>

Promise resolving to CSV blob for download

**`Throws`**

When not authenticated as administrator or export fails

**`Example`**

```typescript
const csvBlob = await sdk.redemptions.exportCSV();
const downloadUrl = URL.createObjectURL(csvBlob);
```

**`Example`**

```typescript
const csvBlob = await sdk.redemptions.exportCSV({
  dateFrom: '2024-01-01',
  dateTo: '2024-12-31'
});
```

#### Defined in

[managers/redemption-manager.ts:850](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L850)

### exportRedeemsCSV

▸ **exportRedeemsCSV**(`options?`): `Promise`<`Blob`>

Admin: Export redemption redeems as CSV

Generates a comprehensive CSV export of all redemption redeem records for
external analysis, reporting, or compliance purposes. This operation
requires administrator privileges and creates a downloadable file.

#### Parameters

| Name | Type | Description |
|  --- | --- | --- |
| `options?` | `Object` | Optional date range filters |
| `options.dateFrom?` | `string` | Start date filter (ISO date string) |
| `options.dateTo?` | `string` | End date filter (ISO date string) |


#### Returns

`Promise`<`Blob`>

Promise resolving to CSV blob for download

**`Throws`**

When not authenticated as administrator or export fails

**`Example`**

```typescript
const csvBlob = await sdk.redemptions.exportRedeemsCSV();
const downloadUrl = URL.createObjectURL(csvBlob);
```

#### Defined in

[managers/redemption-manager.ts:874](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L874)

### getRedemptionService

▸ **getRedemptionService**(): [`RedemptionService`](/sdk-reference/classes/redemptionservice)

Get the full redemption service for advanced operations

Provides access to the complete RedemptionService instance for advanced
redemption operations, custom validation, analytics, and operations not
covered by the high-level manager methods.

#### Returns

[`RedemptionService`](/sdk-reference/classes/redemptionservice)

RedemptionService instance with full API access

**`Example`**

```typescript
const redemptionService = sdk.redemptions.getRedemptionService();

// Access advanced redemption analytics
const analytics = await redemptionService.getRedemptionAnalytics();

// Access custom validation rules
const eligibility = await redemptionService.validateRedemptionEligibility(
  'user-123', 
  'redemption-456'
);

// Access redemption API directly
const redemptionApi = redemptionService.api;

// Use advanced inventory management
const inventory = await redemptionService.getInventoryStatus();
```

#### Defined in

[managers/redemption-manager.ts:908](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L908)

### setRedemptionApproval

▸ **setRedemptionApproval**(`redemptionId`, `status`, `reason?`): `Promise`<`RedemptionDTO`>

Admin: Approve a redemption

Approves a redemption that is pending approval. This operation is only available
when the tenant has redemption approval enabled in their approval settings.

#### Parameters

| Name | Type | Description |
|  --- | --- | --- |
| `redemptionId` | `string` | ID of the redemption to approve |
| `status` | `"approved"` | `"rejected"` | - |
| `reason?` | `string` | - |


#### Returns

`Promise`<`RedemptionDTO`>

Promise resolving to updated redemption with approval metadata

**`Throws`**

When not authenticated as tenant admin or redemption not found

**`Example`**

```ts
`	ypescript
const approved = await sdk.redemptions.approveRedemption('redemption-123');
console.log('Redemption approved at:', approved.approval?.approvedAt);
`
```

#### Defined in

[managers/redemption-manager.ts:932](https://github.com/eXplorins/PERS-sdks/blob/main/packages/pers-sdk/packages/pers-sdk/src/managers/redemption-manager.ts#L932)