Versi: 1.1.0

Enums

The STADATA Flutter SDK provides a comprehensive set of enums designed to simplify API interactions, enhance type safety, and improve code readability. These enums serve as standardized constants for various parameters and response values throughout the SDK, ensuring consistent and predictable behavior across all statistical data operations.

These enums eliminate the need for magic strings, reduce potential errors, and provide IntelliSense support in your IDE, making development more efficient and less error-prone when working with Indonesian statistical data from BPS.

Core Language and Localization

`DataLanguage` Enum

The DataLanguage enum controls the language of data returned from BPS APIs, supporting both Indonesian and English responses where available.

Enum	Parameter Value	Description	Status	Usage Context
`DataLanguage.id`	`ind`	Indonesian language responses	Default	All API calls, recommended for Indonesian users
`DataLanguage.en`	`eng`	English language responses	Available	International users, English documentation

Usage Examples

// Using default Indonesian language
final domains = await StadataFlutter.instance.list.domains();

// Explicitly requesting Indonesian data
final domainsIndonesian = await StadataFlutter.instance.list.domains(
  lang: DataLanguage.id,
);

// Requesting English data where available
final domainsEnglish = await StadataFlutter.instance.list.domains(
  lang: DataLanguage.en,
);

// Language-specific content retrieval
final publication = await StadataFlutter.instance.view.publication(
  id: '03220.2301',
  domain: '0000',
  lang: DataLanguage.id, // Indonesian content
);

Best Practices

Default Behavior: When no language is specified, DataLanguage.id is used automatically
Consistency: Use the same language throughout your application for consistent user experience
Fallback Strategy: Some content may only be available in Indonesian; implement fallback logic when needed
User Preference: Allow users to choose their preferred language and persist this setting

// Implementing language preference with fallback
Future<Publication?> getPublicationWithFallback(
  String id, 
  String domain, 
  DataLanguage preferredLang,
) async {
  try {
    // Try preferred language first
    final publication = await StadataFlutter.instance.view.publication(
      id: id,
      domain: domain,
      lang: preferredLang,
    );
    
    if (publication != null) return publication;
    
    // Fallback to Indonesian if preferred language fails
    if (preferredLang != DataLanguage.id) {
      return await StadataFlutter.instance.view.publication(
        id: id,
        domain: domain,
        lang: DataLanguage.id,
      );
    }
    
    return null;
  } catch (e) {
    // Handle errors appropriately
    return null;
  }
}

Administrative and Geographic Classification

`DomainType` Enum

The DomainType enum simplifies the specification of administrative domain types for geographic and administrative data filtering across Indonesia's governmental structure.

Enum	Parameter Value	Description	Status	Administrative Level
`DomainType.all`	`all`	All administrative domains including national, provincial, and regency levels	Default	National, Provincial, Regency
`DomainType.province`	`prov`	Provincial-level administrative domains only	Available	Provincial
`DomainType.regency`	`kab`	Regency and city-level administrative domains only	Available	Regency/City
`DomainType.regencyByProvince`	`kabbyprov`	Regency domains filtered by specific province	Available	Regency (Province-filtered)

Usage Examples

// Get all administrative domains (national, provincial, regency)
final allDomains = await StadataFlutter.instance.list.domains(
  type: DomainType.all,
);

// Get only provincial domains
final provinces = await StadataFlutter.instance.list.domains(
  type: DomainType.province,
);

// Get only regency/city domains
final regencies = await StadataFlutter.instance.list.domains(
  type: DomainType.regency,
);

// Get regencies within a specific province
final westJavaRegencies = await StadataFlutter.instance.list.domains(
  type: DomainType.regencyByProvince,
  provinceId: '32', // West Java province code
);

Administrative Hierarchy Integration

// Building a hierarchical administrative selector
class AdministrativeSelector {
  static Future<Map<String, List<Domain>>> buildHierarchy() async {
    final hierarchy = <String, List<Domain>>{};
    
    // Load all administrative levels
    final [allDomains, provinces, regencies] = await Future.wait([
      StadataFlutter.instance.list.domains(type: DomainType.all),
      StadataFlutter.instance.list.domains(type: DomainType.province),
      StadataFlutter.instance.list.domains(type: DomainType.regency),
    ]);
    
    hierarchy['all'] = allDomains.data;
    hierarchy['provinces'] = provinces.data;
    hierarchy['regencies'] = regencies.data;
    
    return hierarchy;
  }
  
  static Future<List<Domain>> getRegenciesByProvince(String provinceId) async {
    final regencies = await StadataFlutter.instance.list.domains(
      type: DomainType.regencyByProvince,
      provinceId: provinceId,
    );
    
    return regencies.data;
  }
}

Data Availability and Status

`DataAvailability` Enum

The DataAvailability enum provides standardized status indicators for data availability across all BPS statistical resources, enabling robust error handling and user feedback mechanisms.

Enum	Parameter Value	Description	Usage Context
`DataAvailability.available`	`available`	Data is available and accessible	Successful data retrieval
`DataAvailability.listNotAvailable`	`list-not-available`	Collection or list data is not available	Empty collections, filtered results
`DataAvailability.notAvailable`	`not-available`	Specific data resource is not available	Missing resources, restricted access

Usage Examples

// Checking data availability in API responses
final publicationsResult = await StadataFlutter.instance.list.publications(
  domain: '7200',
  keyword: 'rare-keyword',
);

// Handle different availability statuses
switch (publicationsResult.dataAvailability) {
  case DataAvailability.available:
    print('Found ${publicationsResult.data.length} publications');
    break;
  case DataAvailability.listNotAvailable:
    print('No publications found for the specified criteria');
    break;
  case DataAvailability.notAvailable:
    print('Publication data is not available for this domain');
    break;
}

Robust Data Availability Handling

// Comprehensive data availability handler
class DataAvailabilityHandler {
  static Future<T?> handleDataRetrieval<T>(
    Future<ApiResponse<List<T>>> apiCall,
    String dataType,
  ) async {
    try {
      final result = await apiCall;
      
      switch (result.dataAvailability) {
        case DataAvailability.available:
          if (result.data.isNotEmpty) {
            print('✅ $dataType data loaded: ${result.data.length} items');
            return result.data.first;
          } else {
            print('⚠️ $dataType data available but empty');
            return null;
          }
          
        case DataAvailability.listNotAvailable:
          print('📭 $dataType list not available for current criteria');
          return null;
          
        case DataAvailability.notAvailable:
          print('🚫 $dataType data not available');
          return null;
      }
    } catch (e) {
      print('❌ Error retrieving $dataType: $e');
      return null;
    }
  }
  
  static String getAvailabilityMessage(DataAvailability availability, String dataType) {
    switch (availability) {
      case DataAvailability.available:
        return '$dataType is available';
      case DataAvailability.listNotAvailable:
        return '$dataType list is currently not available';
      case DataAvailability.notAvailable:
        return '$dataType is not available';
    }
  }
}

Statistical Classification Enums

`ClassificationType` Enum Hierarchy

The SDK provides specialized enums for Indonesian Standard Industrial Classification (KBLI) and Indonesian Standard Commodity Classification (KBKI) systems.

`KBLIType` Enum (Industrial Classification)

Industrial classification types with version management for economic activity categorization.

Enum	Parameter Value	Year	Description
`KBLIType.y2009`	`kbli2009`	2009	Original KBLI version based on ISIC Rev. 4
`KBLIType.y2015`	`kbli2015`	2015	Updated version with refined economic categories
`KBLIType.y2017`	`kbli2017`	2017	Enhanced version with additional economic activities
`KBLIType.y2020`	`kbli2020`	2020	Latest version incorporating new economic activities

`KBKIType` Enum (Commodity Classification)

Commodity classification types for product and trade categorization.

Enum	Parameter Value	Year	Description
`KBKIType.y2015`	`kbki2015`	2015	Current commodity classification standard

Usage Examples

// Working with KBLI classifications
const kbliType = KBLIType.y2020;

// Generate proper classification ID
final classificationId = kbliType.urlParamGenerator('A'); // Results in: kbli_2020_A

// Retrieve classification data
final classifications = await StadataFlutter.instance.view.statisticClassifications(
  id: classificationId,
  type: kbliType,
);

// Version comparison workflow
final comparisonResults = await Future.wait([
  StadataFlutter.instance.view.statisticClassifications(
    id: KBLIType.y2015.urlParamGenerator('C'),
    type: KBLIType.y2015,
  ),
  StadataFlutter.instance.view.statisticClassifications(
    id: KBLIType.y2020.urlParamGenerator('C'),
    type: KBLIType.y2020,
  ),
]);

`ClassificationLevel` Enums

Hierarchical level specifications for classification systems.

`KBLILevel` Enum (Industrial Levels)

Enum	Parameter Value	Description	Code Format
`KBLILevel.category`	`category`	Main economic sectors (A-U)	Single letter
`KBLILevel.primaryGroup`	`primary group`	Detailed economic divisions	Two digits
`KBLILevel.group`	`group`	Specific industry classifications	Three digits
`KBLILevel.subGroup`	`subgroup`	Detailed business activities	Four digits
`KBLILevel.cluster`	`cluster`	Most specific economic activities	Five digits

`KBKILevel` Enum (Commodity Levels)

Enum	Parameter Value	Description	Code Format
`KBKILevel.section`	`section`	Major product categories (0-4)	Single digit
`KBKILevel.division`	`division`	Product category divisions	Two digits
`KBKILevel.group`	`group`	Product group classifications	Three digits
`KBKILevel.classes`	`classes`	Specific product classes	Four digits
`KBKILevel.subClass`	`subclass`	Detailed product specifications	Five digits
`KBKILevel.commodityGroup`	`commodity group`	Commodity group classifications	Seven digits
`KBKILevel.commodity`	`commodity`	Individual commodity identification	Ten digits

Code Validation Examples

// KBLI code validation
final categoryValid = KBLILevel.category.validateCode('A'); // true
final groupValid = KBLILevel.group.validateCode('123'); // true
final invalidCode = KBLILevel.category.validateCode('123'); // false

// KBKI code validation  
final sectionValid = KBKILevel.section.validateCode('0'); // true
final commodityValid = KBKILevel.commodity.validateCode('1234567890'); // true

Foreign Trade Enums

The SDK provides three enums for querying foreign trade data via the dataexim endpoint.

`TradeSource` Enum

Specifies the direction of trade data to retrieve.

Enum	API Value (`sumber`)	Description
`TradeSource.export`	`1`	Export trade data
`TradeSource.import_`	`2`	Import trade data (named with trailing underscore to avoid Dart keyword conflict)

Usage Example

final exportData = await StadataFlutter.instance.list.trade(
  source: TradeSource.export,
  period: TradePeriod.annually,
  hsCode: '27',
  hsType: HSCodeType.twoDigit,
  year: '2023',
);

final importData = await StadataFlutter.instance.list.trade(
  source: TradeSource.import_,
  period: TradePeriod.annually,
  hsCode: '27',
  hsType: HSCodeType.twoDigit,
  year: '2023',
);

`TradePeriod` Enum

Specifies the reporting period aggregation type for trade data.

Enum	API Value (`periode`)	Description
`TradePeriod.monthly`	`1`	Monthly trade data aggregation
`TradePeriod.annually`	`2`	Annual trade data aggregation

Usage Example

// Get monthly trade data
final monthlyTrade = await StadataFlutter.instance.list.trade(
  source: TradeSource.export,
  period: TradePeriod.monthly,
  hsCode: '01',
  hsType: HSCodeType.twoDigit,
  year: '2023',
);

// Get annual trade data
final annualTrade = await StadataFlutter.instance.list.trade(
  source: TradeSource.export,
  period: TradePeriod.annually,
  hsCode: '01',
  hsType: HSCodeType.twoDigit,
  year: '2023',
);

`HSCodeType` Enum

Specifies the HS (Harmonized System) code digit classification level.

Enum	API Value (`jenishs`)	Description
`HSCodeType.twoDigit`	`1`	Two-digit HS code (broad commodity groups, e.g. `'01'`)
`HSCodeType.full`	`2`	Full HS code (detailed commodity classification, e.g. `'0101'`)

Usage Example

// Query using two-digit HS code (broad category: Live Animals)
final broadQuery = await StadataFlutter.instance.list.trade(
  source: TradeSource.export,
  period: TradePeriod.annually,
  hsCode: '01',
  hsType: HSCodeType.twoDigit,
  year: '2023',
);

// Query using full HS code (specific: Live horses, asses, mules)
final specificQuery = await StadataFlutter.instance.list.trade(
  source: TradeSource.export,
  period: TradePeriod.annually,
  hsCode: '0101',
  hsType: HSCodeType.full,
  year: '2023',
);

Factory Constructors

All three trade enums support fromValue() factory constructors for deserialization:

final source = TradeSource.fromValue(1);    // TradeSource.export
final period = TradePeriod.fromValue(2);    // TradePeriod.annually
final hsType = HSCodeType.fromValue(1);     // HSCodeType.twoDigit

Practical Integration Patterns

Enum-Driven Configuration

// Configuration class using enums for type safety
class StatisticalDataConfig {
  final DataLanguage language;
  final DomainType domainType;
  final ClassificationType classificationType;
  
  const StatisticalDataConfig({
    this.language = DataLanguage.id,
    this.domainType = DomainType.all,
    required this.classificationType,
  });
  
  // Factory constructors for common configurations
  factory StatisticalDataConfig.indonesian() => const StatisticalDataConfig(
    language: DataLanguage.id,
    domainType: DomainType.all,
    classificationType: KBLIType.y2020,
  );
  
  factory StatisticalDataConfig.english() => const StatisticalDataConfig(
    language: DataLanguage.en,
    domainType: DomainType.all,
    classificationType: KBLIType.y2020,
  );
}

Error Handling with Enums

// Enum-based error categorization
enum DataRetrievalError {
  networkError,
  authenticationError,
  dataNotAvailable,
  invalidParameters,
  serviceUnavailable,
}

class EnumBasedErrorHandler {
  static DataRetrievalError categorizeError(dynamic error) {
    if (error is ApiKeyNotFoundException) {
      return DataRetrievalError.authenticationError;
    } else if (error is ApiException) {
      return DataRetrievalError.serviceUnavailable;
    } else if (error is ValidationException) {
      return DataRetrievalError.invalidParameters;
    } else {
      return DataRetrievalError.networkError;
    }
  }
  
  static String getErrorMessage(DataRetrievalError error) {
    switch (error) {
      case DataRetrievalError.networkError:
        return 'Network connection issue. Please check your internet connection.';
      case DataRetrievalError.authenticationError:
        return 'Invalid API key. Please check your credentials.';
      case DataRetrievalError.dataNotAvailable:
        return 'Requested data is not available.';
      case DataRetrievalError.invalidParameters:
        return 'Invalid request parameters.';
      case DataRetrievalError.serviceUnavailable:
        return 'Service is temporarily unavailable.';
    }
  }
}

Enum Utility Extensions

Custom Extension Methods

// Useful extensions for enum functionality
extension DataLanguageExtension on DataLanguage {
  String get displayName {
    switch (this) {
      case DataLanguage.id:
        return 'Bahasa Indonesia';
      case DataLanguage.en:
        return 'English';
    }
  }
  
  String get flagEmoji {
    switch (this) {
      case DataLanguage.id:
        return '🇮🇩';
      case DataLanguage.en:
        return '🇺🇸';
    }
  }
}

extension DomainTypeExtension on DomainType {
  String get description {
    switch (this) {
      case DomainType.all:
        return 'All administrative levels';
      case DomainType.province:
        return 'Provincial level only';
      case DomainType.regency:
        return 'Regency/City level only';
      case DomainType.regencyByProvince:
        return 'Regencies within province';
    }
  }
  
  IconData get icon {
    switch (this) {
      case DomainType.all:
        return Icons.public;
      case DomainType.province:
        return Icons.location_on;
      case DomainType.regency:
        return Icons.location_city;
      case DomainType.regencyByProvince:
        return Icons.filter_list;
    }
  }
}

Performance and Best Practices

Enum Usage Guidelines

Type Safety: Always use enums instead of string literals for parameters
Default Values: Leverage default enum values to simplify API calls
Validation: Use enum validation methods before making API calls
Consistency: Maintain consistent enum usage throughout your application
Documentation: Document your enum choices for team understanding

Performance Optimization

// Enum-based caching strategy
class EnumBasedCache {
  static final Map<String, dynamic> _cache = {};
  
  static String _generateCacheKey(
    String endpoint,
    DataLanguage language,
    DomainType domainType,
    Map<String, dynamic> params,
  ) {
    return '$endpoint_${language.name}_${domainType.name}_${params.hashCode}';
  }
  
  static Future<T?> getCachedOrFetch<T>(
    String endpoint,
    DataLanguage language,
    DomainType domainType,
    Map<String, dynamic> params,
    Future<T> Function() fetcher,
  ) async {
    final cacheKey = _generateCacheKey(endpoint, language, domainType, params);
    
    if (_cache.containsKey(cacheKey)) {
      return _cache[cacheKey] as T;
    }
    
    final result = await fetcher();
    _cache[cacheKey] = result;
    return result;
  }
}

The comprehensive enum system in STADATA Flutter SDK provides type-safe, efficient, and maintainable ways to interact with Indonesian statistical data. By leveraging these enums effectively, you can build robust applications that handle the complexity of statistical data classification and administrative hierarchies with ease.

Summary

These enums serve as the foundation for type-safe interactions with the STADATA Flutter SDK:

DataLanguage: Controls response language (Indonesian/English)
DomainType: Manages administrative domain filtering
DataAvailability: Handles data availability status
Classification Enums: Provide structured access to KBLI/KBKI systems
Level Enums: Enable hierarchical navigation of classifications

By using these enums consistently, you ensure reliable, maintainable, and error-free integration with Indonesia's official statistical data through the BPS API system.

Core Language and Localization​

DataLanguage Enum​

Usage Examples​

Best Practices​

Administrative and Geographic Classification​

DomainType Enum​

Usage Examples​

Administrative Hierarchy Integration​

Data Availability and Status​

DataAvailability Enum​

Usage Examples​

Robust Data Availability Handling​

Statistical Classification Enums​

ClassificationType Enum Hierarchy​

KBLIType Enum (Industrial Classification)​

KBKIType Enum (Commodity Classification)​

Usage Examples​

ClassificationLevel Enums​

KBLILevel Enum (Industrial Levels)​

KBKILevel Enum (Commodity Levels)​

Code Validation Examples​

Foreign Trade Enums​

TradeSource Enum​

Usage Example​

TradePeriod Enum​

Usage Example​

HSCodeType Enum​

Usage Example​

Factory Constructors​

Practical Integration Patterns​

Enum-Driven Configuration​

Error Handling with Enums​

Enum Utility Extensions​

Custom Extension Methods​

Performance and Best Practices​

Enum Usage Guidelines​

Performance Optimization​

Summary​

Core Language and Localization

`DataLanguage` Enum

Usage Examples

Best Practices

Administrative and Geographic Classification

`DomainType` Enum

Usage Examples

Administrative Hierarchy Integration

Data Availability and Status

`DataAvailability` Enum

Usage Examples

Robust Data Availability Handling

Statistical Classification Enums

`ClassificationType` Enum Hierarchy

`KBLIType` Enum (Industrial Classification)

`KBKIType` Enum (Commodity Classification)

Usage Examples

`ClassificationLevel` Enums

`KBLILevel` Enum (Industrial Levels)

`KBKILevel` Enum (Commodity Levels)

Code Validation Examples

Foreign Trade Enums

`TradeSource` Enum

Usage Example

`TradePeriod` Enum

Usage Example

`HSCodeType` Enum

Usage Example

Factory Constructors

Practical Integration Patterns

Enum-Driven Configuration

Error Handling with Enums

Enum Utility Extensions

Custom Extension Methods

Performance and Best Practices

Enum Usage Guidelines

Performance Optimization

Summary