stadata-js 1.1.0 → 2.0.1

package/dist/index.d.mts

@@ -48,19 +48,6 @@ interface NetworkInterceptor {
     onResponse?(response: Response): Response | Promise<Response>;
     onError?(error: Error): Error | Promise<Error> | null;
 }
-declare abstract class BaseNetworkInterceptor implements NetworkInterceptor {
-    onRequest?(url: string, init: RequestInit): InterceptedRequest | Promise<InterceptedRequest>;
-    onResponse?(response: Response): Response | Promise<Response>;
-    onError?(error: Error): Error | Promise<Error> | null;
-}
-
-declare class AuthInterceptor extends BaseNetworkInterceptor {
-    private apiKey;
-    constructor(apiKey: string);
-    onRequest(url: string, init: RequestInit): InterceptedRequest;
-    setApiKey(apiKey: string): void;
-    getApiKey(): string;
-}
 
 declare enum LogLevel {
     DEBUG = 0,
@@ -70,73 +57,6 @@ declare enum LogLevel {
     FATAL = 4,
     NONE = 5
 }
-interface LogEntry {
-    level: LogLevel;
-    message: string;
-    timestamp: Date;
-    data?: unknown;
-    error?: Error;
-}
-interface LogPrinter {
-    print(entry: LogEntry): void;
-}
-interface LogFilter {
-    shouldLog(entry: LogEntry): boolean;
-}
-declare class ConsoleLogPrinter implements LogPrinter {
-    print(entry: LogEntry): void;
-}
-declare class ProductionLogFilter implements LogFilter {
-    private minLevel;
-    constructor(minLevel?: LogLevel);
-    shouldLog(entry: LogEntry): boolean;
-}
-declare class Logger {
-    private static instance;
-    private printer;
-    private filter;
-    private enabled;
-    private constructor();
-    static getInstance(): Logger;
-    configure(options: {
-        printer?: LogPrinter;
-        filter?: LogFilter;
-        enabled?: boolean;
-    }): void;
-    debug(message: string, data?: unknown): void;
-    info(message: string, data?: unknown): void;
-    warn(message: string, data?: unknown): void;
-    error(message: string, error?: unknown): void;
-    fatal(message: string, error?: unknown): void;
-    private log;
-    enable(): void;
-    disable(): void;
-}
-
-declare class LoggingInterceptor extends BaseNetworkInterceptor {
-    private logger;
-    constructor(logger?: Logger);
-    onRequest(url: string, init: RequestInit): InterceptedRequest;
-    onResponse(response: Response): Response;
-    onError(error: Error): Error;
-}
-
-interface RetryConfig {
-    maxRetries: number;
-    retryDelay: number;
-    retryableStatusCodes?: number[];
-    exponentialBackoff?: boolean;
-}
-declare class RetryInterceptor extends BaseNetworkInterceptor {
-    private logger;
-    private config;
-    private retryCount;
-    constructor(config?: Partial<RetryConfig>, logger?: Logger);
-    onResponse(response: Response): Promise<Response>;
-    private sleep;
-    resetRetryCount(url: string): void;
-    clearAllRetryCounts(): void;
-}
 
 declare class CancelToken {
     private abortController;
@@ -155,17 +75,6 @@ declare class CancelToken {
     };
 }
 
-declare class DateHelper {
-    static parse(dateString: string | null | undefined): Date | null;
-    static format(date: Date | null | undefined): string | null;
-    static formatReadable(date: Date | null | undefined): string | null;
-    static isValid(dateString: string): boolean;
-    static toTimestamp(dateString: string): number | null;
-    static fromTimestamp(timestamp: number): Date;
-    static now(): string;
-    static nowTimestamp(): number;
-}
-
 interface NetworkClientConfig {
     baseURL?: string;
     timeout?: number;
@@ -210,13 +119,13 @@ declare abstract class BaseEntity implements IBaseEntity {
     copyWith(updates: Partial<Record<string, unknown>>): this;
 }
 
-declare abstract class UseCase<Params, Type> {
-    abstract execute(params: Params): Promise<Result<Type, Failure>>;
-    dispose?(): void;
-}
-declare abstract class NoParamsUseCase<Type> extends UseCase<void, Type> {
-    abstract execute(): Promise<Result<Type, Failure>>;
-    call(): Promise<Result<Type, Failure>>;
+declare class Domain extends BaseEntity {
+    readonly id: string;
+    readonly name: string;
+    readonly url: string;
+    constructor(id: string, name: string, url: string);
+    toJson(): Record<string, unknown>;
+    static fromJson(json: Record<string, unknown>): Domain;
 }
 
 declare class Pagination extends BaseEntity {
@@ -234,18 +143,6 @@ declare class Pagination extends BaseEntity {
     static fromJson(json: Record<string, unknown>): Pagination;
 }
 
-declare class ApiResponse<T> extends BaseEntity {
-    readonly data: T[];
-    readonly dataAvailability: string;
-    readonly pagination?: Pagination | undefined;
-    constructor(data: T[], dataAvailability: string, pagination?: Pagination | undefined);
-    get isAvailable(): boolean;
-    get totalItems(): number;
-    get hasData(): boolean;
-    toJson(): Record<string, unknown>;
-    static fromJson<T>(json: Record<string, unknown>, itemFactory: (item: Record<string, unknown>) => T): ApiResponse<T>;
-}
-
 declare class ListResult<T> extends BaseEntity {
     readonly data: T[];
     readonly pagination: Pagination;
@@ -303,68 +200,76 @@ declare enum DomainType {
 
 type JSON = Record<string, unknown>;
 interface BaseListParams {
-    domain?: string;
     lang?: DataLanguage;
     page?: number;
     perPage?: number;
     cancelToken?: CancelToken;
 }
-interface DomainListParams extends Omit<BaseListParams, 'domain'> {
+interface BaseDomainListParams extends BaseListParams {
+    domain: string;
+}
+interface DomainListParams extends BaseListParams {
     type: DomainType;
     provinceCode?: string;
     keyword?: string;
 }
-interface PublicationListParams extends BaseListParams {
+interface PublicationListParams extends BaseDomainListParams {
     keyword?: string;
     month?: number;
     year?: number;
 }
-interface InfographicListParams extends BaseListParams {
+interface InfographicListParams extends BaseDomainListParams {
     keyword?: string;
 }
-interface StaticTableListParams extends BaseListParams {
+interface StaticTableListParams extends BaseDomainListParams {
     keyword?: string;
     month?: number;
     year?: number;
 }
-interface NewsListParams extends BaseListParams {
+interface NewsListParams extends BaseDomainListParams {
     keyword?: string;
     month?: number;
     year?: number;
     newsCategoryId?: string;
 }
-interface NewsCategoryListParams extends BaseListParams {
+interface NewsCategoryListParams extends BaseDomainListParams {
 }
-interface PressReleaseListParams extends BaseListParams {
+interface PressReleaseListParams extends BaseDomainListParams {
     keyword?: string;
     month?: number;
     year?: number;
 }
-interface SubjectListParams extends BaseListParams {
+interface SubjectListParams extends BaseDomainListParams {
+    subjectCategoryId?: number;
 }
-interface SubjectCategoryListParams extends BaseListParams {
+interface SubjectCategoryListParams extends BaseDomainListParams {
 }
-interface StrategicIndicatorListParams extends BaseListParams {
+interface StrategicIndicatorListParams extends BaseDomainListParams {
+    variableId?: number;
 }
-interface VariableListParams extends BaseListParams {
+interface VariableListParams extends BaseDomainListParams {
     subjectId?: number;
+    year?: number;
+    showExistingVariables?: boolean;
     showDeleted?: boolean;
 }
-interface VerticalVariableListParams extends BaseListParams {
+interface VerticalVariableListParams extends BaseDomainListParams {
     variableId?: number;
 }
-interface UnitListParams extends BaseListParams {
+interface UnitListParams extends BaseDomainListParams {
+    variableId?: number;
 }
-interface PeriodListParams extends BaseListParams {
+interface PeriodListParams extends BaseDomainListParams {
     variableId?: number;
 }
-interface DerivedPeriodListParams extends BaseListParams {
+interface DerivedPeriodListParams extends BaseDomainListParams {
     variableId?: number;
 }
-interface DerivedVariableListParams extends BaseListParams {
+interface DerivedVariableListParams extends BaseDomainListParams {
     variableId?: number;
+    verticalGroup?: number;
 }
-interface DynamicTableParams extends BaseListParams {
+interface DynamicTableParams extends BaseDomainListParams {
     variableId: number;
     periodId: string;
     derivedVariableId?: number;
@@ -372,6 +277,7 @@ interface DynamicTableParams extends BaseListParams {
     derivedPeriodId?: string;
 }
 interface StatisticClassificationListParams extends BaseListParams {
+    domain?: string;
     type?: ClassificationType;
     level?: ClassificationLevel;
     keyword?: string;
@@ -423,38 +329,10 @@ type ResponseData<T> = {
     };
 };
 
-declare class Domain extends BaseEntity {
-    readonly id: string;
-    readonly name: string;
-    readonly url: string;
-    constructor(id: string, name: string, url: string);
-    toJson(): Record<string, unknown>;
-    static fromJson(json: Record<string, unknown>): Domain;
-}
-
-interface DomainRepository {
-    getAll(params?: DomainListParams): Promise<Result<ListResult<Domain>, ApiFailure>>;
-}
-
-declare class GetAllDomains extends UseCase<DomainListParams | undefined, ListResult<Domain>> {
-    private repository;
-    constructor(repository: DomainRepository);
-    execute(params?: DomainListParams): Promise<Result<ListResult<Domain>, ApiFailure>>;
-}
-
-declare class Injector {
-    private static instance;
-    private container;
-    private factories;
-    private constructor();
-    static getInstance(): Injector;
-    register<T>(key: string, instance: T): void;
-    registerFactory<T>(key: string, factory: () => T): void;
-    resolve<T>(key: string): T;
-    has(key: string): boolean;
-    clear(): void;
-    remove(key: string): void;
+interface UseDomains {
+    fetchDomainList: (params: DomainListParams) => Promise<Result<ListResult<Domain>, ApiFailure>>;
 }
+declare function useDomains(client?: StadataClient): UseDomains;
 
 declare class RelatedPublication extends BaseEntity {
     readonly id: string;
@@ -486,51 +364,11 @@ declare class Publication extends BaseEntity {
     static fromJson(json: Record<string, unknown>): Publication;
 }
 
-interface PublicationRepository {
-    getAll(params: PublicationListParams): Promise<Result<ListResult<Publication>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<Publication, ApiFailure>>;
-}
-
-declare class GetAllPublications {
-    private readonly repository;
-    constructor(repository: PublicationRepository);
-    execute(params: PublicationListParams): Promise<Result<ListResult<Publication>, ApiFailure>>;
-}
-
-declare class GetPublicationById {
-    private readonly repository;
-    constructor(repository: PublicationRepository);
-    execute(params: ViewParams): Promise<Result<Publication, ApiFailure>>;
-}
-
-declare class Infographic extends BaseEntity {
-    readonly id: string;
-    readonly title: string;
-    readonly image: string;
-    readonly category: number;
-    readonly downloadUrl: string;
-    readonly description: string | null;
-    constructor(id: string, title: string, image: string, category: number, downloadUrl: string, description: string | null);
-    toJson(): Record<string, unknown>;
-    static fromJson(json: Record<string, unknown>): Infographic;
-}
-
-interface InfographicRepository {
-    getAll(params: InfographicListParams): Promise<Result<ListResult<Infographic>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<Infographic, ApiFailure>>;
-}
-
-declare class GetAllInfographics {
-    private readonly repository;
-    constructor(repository: InfographicRepository);
-    execute(params: InfographicListParams): Promise<Result<ListResult<Infographic>, ApiFailure>>;
-}
-
-declare class GetInfographicById {
-    private readonly repository;
-    constructor(repository: InfographicRepository);
-    execute(params: ViewParams): Promise<Result<Infographic, ApiFailure>>;
+interface UsePublications {
+    fetchPublicationList: (params: PublicationListParams) => Promise<Result<ListResult<Publication>, ApiFailure>>;
+    fetchPublicationDetail: (params: ViewParams) => Promise<Result<Publication, ApiFailure>>;
 }
+declare function usePublications(client?: StadataClient): UsePublications;
 
 declare const ApiConstant: {
     readonly BASE_URL: "https://webapi.bps.go.id/v1/api";
@@ -578,111 +416,6 @@ declare const ApiEndpoint: {
     readonly TRADE: "/dataexim";
 };
 
-declare const QueryParamConstant: {
-    readonly KEY: "key";
-    readonly DOMAIN: "domain";
-    readonly LANG: "lang";
-    readonly PAGE: "page";
-    readonly PER_PAGE: "per_page";
-    readonly KEYWORD: "keyword";
-    readonly MONTH: "month";
-    readonly YEAR: "year";
-    readonly SUBJECT: "subj";
-    readonly VARIABLE: "var";
-    readonly TURVAR: "turvar";
-    readonly TURTH: "turth";
-    readonly PERIOD: "th";
-    readonly TYPE: "type";
-    readonly TABLE: "table";
-    readonly MODEL: "model";
-    readonly ID: "id";
-    readonly SHOW_DELETED: "show_deleted";
-};
-
-declare class StadataException extends Error {
-    constructor(message: string);
-}
-declare class ApiException extends StadataException {
-    readonly statusCode?: number | undefined;
-    readonly response?: unknown | undefined;
-    constructor(message: string, statusCode?: number | undefined, response?: unknown | undefined);
-}
-declare class CancelledException extends StadataException {
-    constructor(message?: string);
-}
-declare class NetworkException extends StadataException {
-    constructor(message: string);
-}
-declare class TimeoutException extends StadataException {
-    constructor(message?: string);
-}
-declare class NotFoundException extends ApiException {
-    constructor(message?: string);
-}
-declare class UnauthorizedException extends ApiException {
-    constructor(message?: string);
-}
-declare class ForbiddenException extends ApiException {
-    constructor(message?: string);
-}
-declare class ServerException extends ApiException {
-    constructor(message?: string, statusCode?: number);
-}
-
-declare class News extends BaseEntity {
-    readonly id: string;
-    readonly title: string;
-    readonly content: string;
-    readonly releaseDate: string;
-    readonly categoryId: number;
-    readonly picture: string | null;
-    constructor(id: string, title: string, content: string, releaseDate: string, categoryId: number, picture: string | null);
-    toJson(): Record<string, unknown>;
-    static fromJson(json: Record<string, unknown>): News;
-}
-
-interface NewsRepository {
-    getAll(params: NewsListParams): Promise<Result<ListResult<News>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<News, ApiFailure>>;
-}
-
-declare class GetAllNews {
-    private readonly repository;
-    constructor(repository: NewsRepository);
-    execute(params: NewsListParams): Promise<Result<ListResult<News>, ApiFailure>>;
-}
-
-declare class GetNewsById {
-    private readonly repository;
-    constructor(repository: NewsRepository);
-    execute(params: ViewParams): Promise<Result<News, ApiFailure>>;
-}
-
-declare class NewsCategory extends BaseEntity {
-    readonly id: string;
-    readonly name: string;
-    constructor(id: string, name: string);
-    toJson(): Record<string, unknown>;
-    static fromJson(json: Record<string, unknown>): NewsCategory;
-}
-
-interface NewsCategoryRepository {
-    getAll(params?: NewsCategoryListParams): Promise<Result<ListResult<NewsCategory>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<NewsCategory, ApiFailure>>;
-}
-
-declare class GetAllNewsCategories implements UseCase<NewsCategoryListParams | undefined, ListResult<NewsCategory>> {
-    private readonly repository;
-    constructor(repository: NewsCategoryRepository);
-    execute(params?: NewsCategoryListParams): Promise<Result<ListResult<NewsCategory>, ApiFailure>>;
-}
-
-declare class GetNewsCategoryById implements UseCase<ViewParams, NewsCategory> {
-    private readonly repository;
-    constructor(repository: NewsCategoryRepository);
-    execute(params: ViewParams): Promise<Result<NewsCategory, ApiFailure>>;
-}
-
 declare class PressRelease extends BaseEntity {
     readonly id: number;
     readonly subjectId: number;
@@ -700,22 +433,11 @@ declare class PressRelease extends BaseEntity {
     static fromJson(json: Record<string, unknown>): PressRelease;
 }
 
-interface PressReleaseRepository {
-    getAll(params: PressReleaseListParams): Promise<Result<ListResult<PressRelease>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<PressRelease, ApiFailure>>;
-}
-
-declare class GetAllPressReleases {
-    private readonly repository;
-    constructor(repository: PressReleaseRepository);
-    execute(params: PressReleaseListParams): Promise<Result<ListResult<PressRelease>, ApiFailure>>;
-}
-
-declare class GetPressReleaseById {
-    private readonly repository;
-    constructor(repository: PressReleaseRepository);
-    execute(params: ViewParams): Promise<Result<PressRelease, ApiFailure>>;
+interface UsePressReleases {
+    fetchPressReleaseList: (params: PressReleaseListParams) => Promise<Result<ListResult<PressRelease>, ApiFailure>>;
+    fetchPressReleaseDetail: (params: ViewParams) => Promise<Result<PressRelease, ApiFailure>>;
 }
+declare function usePressReleases(client?: StadataClient): UsePressReleases;
 
 declare class StaticTable extends BaseEntity {
     readonly id: string;
@@ -729,108 +451,148 @@ declare class StaticTable extends BaseEntity {
     static fromJson(json: Record<string, unknown>): StaticTable;
 }
 
-interface StaticTableRepository {
-    getAll(params: StaticTableListParams): Promise<Result<ListResult<StaticTable>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<StaticTable, ApiFailure>>;
-}
-
-declare class GetAllStaticTables {
-    private readonly repository;
-    constructor(repository: StaticTableRepository);
-    execute(params: StaticTableListParams): Promise<Result<ListResult<StaticTable>, ApiFailure>>;
+interface UseStaticTables {
+    fetchStaticTableList: (params: StaticTableListParams) => Promise<Result<ListResult<StaticTable>, ApiFailure>>;
+    fetchStaticTableDetail: (params: ViewParams) => Promise<Result<StaticTable, ApiFailure>>;
 }
+declare function useStaticTables(client?: StadataClient): UseStaticTables;
 
-declare class GetStaticTableById {
-    private readonly repository;
-    constructor(repository: StaticTableRepository);
-    execute(params: ViewParams): Promise<Result<StaticTable, ApiFailure>>;
+declare class VariableInfo extends BaseEntity {
+    readonly value: number;
+    readonly label: string;
+    readonly unit: string;
+    readonly subject: string;
+    readonly definition: string;
+    readonly notes: string;
+    readonly decimal?: number | undefined;
+    constructor(value: number, label: string, unit: string, subject: string, definition: string, notes: string, decimal?: number | undefined);
+    toJson(): Record<string, unknown>;
+    static fromJson(json: Record<string, unknown>): VariableInfo;
 }
-
-declare class Subject extends BaseEntity {
-    readonly id: number;
-    readonly name: string;
-    readonly categoryId: number;
-    readonly category: string;
-    constructor(id: number, name: string, categoryId: number, category: string);
+declare class VerticalVariableInfo extends BaseEntity {
+    readonly value: number | string;
+    readonly label: string;
+    constructor(value: number | string, label: string);
     toJson(): Record<string, unknown>;
-    static fromJson(json: Record<string, unknown>): Subject;
+    static fromJson(json: Record<string, unknown>): VerticalVariableInfo;
 }
-
-interface SubjectRepository {
-    getAll(params?: SubjectListParams): Promise<Result<ListResult<Subject>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<Subject, ApiFailure>>;
+declare class PeriodInfo extends VerticalVariableInfo {
+    static fromJson(json: Record<string, unknown>): PeriodInfo;
 }
-
-declare class GetAllSubjects implements UseCase<SubjectListParams | undefined, ListResult<Subject>> {
-    private readonly repository;
-    constructor(repository: SubjectRepository);
-    execute(params?: SubjectListParams): Promise<Result<ListResult<Subject>, ApiFailure>>;
+declare class SubjectInfo extends BaseEntity {
+    readonly value: number;
+    readonly label: string;
+    constructor(value: number, label: string);
+    toJson(): Record<string, unknown>;
+    static fromJson(json: Record<string, unknown>): SubjectInfo;
 }
-
-declare class GetSubjectById implements UseCase<ViewParams, Subject> {
-    private readonly repository;
-    constructor(repository: SubjectRepository);
-    execute(params: ViewParams): Promise<Result<Subject, ApiFailure>>;
+declare class RelatedTable extends BaseEntity {
+    readonly id: string;
+    readonly title: string;
+    readonly tableSource: number;
+    readonly lastUpdate: string | null;
+    readonly link: string;
+    constructor(id: string, title: string, tableSource: number, lastUpdate: string | null, link: string);
+    toJson(): Record<string, unknown>;
+    static fromJson(json: Record<string, unknown>): RelatedTable;
 }
 
-declare class SubjectCategory extends BaseEntity {
-    readonly id: number;
-    readonly name: string;
-    constructor(id: number, name: string);
+declare class DynamicTable extends BaseEntity {
+    readonly subjects: SubjectInfo[];
+    readonly variables: VariableInfo[];
+    readonly verticalVariables: VerticalVariableInfo[];
+    readonly verticalVariableLabel: string;
+    readonly periods: PeriodInfo[];
+    readonly derivedVariables: VerticalVariableInfo[];
+    readonly derivedPeriods: VerticalVariableInfo[];
+    readonly dataContent: Record<string, unknown>;
+    readonly related: RelatedTable[];
+    readonly lastUpdate?: string | null | undefined;
+    constructor(subjects: SubjectInfo[], variables: VariableInfo[], verticalVariables: VerticalVariableInfo[], verticalVariableLabel: string, periods: PeriodInfo[], derivedVariables: VerticalVariableInfo[], derivedPeriods: VerticalVariableInfo[], dataContent: Record<string, unknown>, related: RelatedTable[], lastUpdate?: string | null | undefined);
     toJson(): Record<string, unknown>;
-    static fromJson(json: Record<string, unknown>): SubjectCategory;
+    static fromJson(json: Record<string, unknown>): DynamicTable;
+    getDataValue(vervarValue: number | string, varValue: number | string, turvarValue: number | string, tahunValue: number | string, turtahunValue: number | string): unknown;
+    toStructuredData(): {
+        subject_id: number;
+        subject_label: string;
+        variable_id: number;
+        variable_label: string;
+        variable_unit: string;
+        vertical_variable_label: string;
+        last_update: string | null | undefined;
+        data: Array<{
+            id: number | string;
+            label: string;
+            data: Array<{
+                id: number | string;
+                label: string;
+                data: Array<{
+                    id: number | string;
+                    label: string;
+                    value?: unknown;
+                    data?: Array<{
+                        id: number | string;
+                        label: string;
+                        value: unknown;
+                    }>;
+                }>;
+            }>;
+        }>;
+    };
 }
 
-interface SubjectCategoryRepository {
-    getAll(params?: SubjectCategoryListParams): Promise<Result<ListResult<SubjectCategory>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<SubjectCategory, ApiFailure>>;
+interface UseDynamicTables {
+    fetchDynamicTableList: (params: DynamicTableParams) => Promise<Result<DynamicTable, ApiFailure>>;
 }
+declare function useDynamicTables(client?: StadataClient): UseDynamicTables;
 
-declare class GetAllSubjectCategories implements UseCase<SubjectCategoryListParams | undefined, ListResult<SubjectCategory>> {
-    private readonly repository;
-    constructor(repository: SubjectCategoryRepository);
-    execute(params?: SubjectCategoryListParams): Promise<Result<ListResult<SubjectCategory>, ApiFailure>>;
+declare class Infographic extends BaseEntity {
+    readonly id: string;
+    readonly title: string;
+    readonly image: string;
+    readonly category: number;
+    readonly downloadUrl: string;
+    readonly description: string | null;
+    constructor(id: string, title: string, image: string, category: number, downloadUrl: string, description: string | null);
+    toJson(): Record<string, unknown>;
+    static fromJson(json: Record<string, unknown>): Infographic;
 }
 
-declare class GetSubjectCategoryById implements UseCase<ViewParams, SubjectCategory> {
-    private readonly repository;
-    constructor(repository: SubjectCategoryRepository);
-    execute(params: ViewParams): Promise<Result<SubjectCategory, ApiFailure>>;
+interface UseInfographics {
+    fetchInfographicList: (params: InfographicListParams) => Promise<Result<ListResult<Infographic>, ApiFailure>>;
 }
+declare function useInfographics(client?: StadataClient): UseInfographics;
 
-declare class StrategicIndicator extends BaseEntity {
-    readonly variableId: number;
-    readonly indicatorId: number;
-    readonly subjectCsa: number;
+declare class News extends BaseEntity {
+    readonly id: string;
     readonly title: string;
-    readonly name: string;
-    readonly dataSource: string;
-    readonly value: number;
-    readonly unit: string;
-    readonly category: number;
-    readonly hashId: string;
-    readonly period: string;
-    constructor(variableId: number, indicatorId: number, subjectCsa: number, title: string, name: string, dataSource: string, value: number, unit: string, category: number, hashId: string, period: string);
+    readonly content: string;
+    readonly releaseDate: string;
+    readonly categoryId: number;
+    readonly picture: string | null;
+    constructor(id: string, title: string, content: string, releaseDate: string, categoryId: number, picture: string | null);
     toJson(): Record<string, unknown>;
-    static fromJson(json: Record<string, unknown>): StrategicIndicator;
+    static fromJson(json: Record<string, unknown>): News;
 }
 
-interface StrategicIndicatorRepository {
-    getAll(params?: StrategicIndicatorListParams): Promise<Result<ListResult<StrategicIndicator>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<StrategicIndicator, ApiFailure>>;
+interface UseNews {
+    fetchNewList: (params: NewsListParams) => Promise<Result<ListResult<News>, ApiFailure>>;
+    fetchNewDetail: (params: ViewParams) => Promise<Result<News, ApiFailure>>;
 }
+declare function useNews(client?: StadataClient): UseNews;
 
-declare class GetAllStrategicIndicators implements UseCase<StrategicIndicatorListParams | undefined, ListResult<StrategicIndicator>> {
-    private readonly repository;
-    constructor(repository: StrategicIndicatorRepository);
-    execute(params?: StrategicIndicatorListParams): Promise<Result<ListResult<StrategicIndicator>, ApiFailure>>;
+declare class NewsCategory extends BaseEntity {
+    readonly id: string;
+    readonly name: string;
+    constructor(id: string, name: string);
+    toJson(): Record<string, unknown>;
+    static fromJson(json: Record<string, unknown>): NewsCategory;
 }
 
-declare class GetStrategicIndicatorById implements UseCase<ViewParams, StrategicIndicator> {
-    private readonly repository;
-    constructor(repository: StrategicIndicatorRepository);
-    execute(params: ViewParams): Promise<Result<StrategicIndicator, ApiFailure>>;
+interface UseNewsCategories {
+    fetchNewsCategoryList: (params: NewsCategoryListParams) => Promise<Result<ListResult<NewsCategory>, ApiFailure>>;
 }
+declare function useNewsCategories(client?: StadataClient): UseNewsCategories;
 
 declare class Variable extends BaseEntity {
     readonly id: number;
@@ -851,22 +613,11 @@ declare class Variable extends BaseEntity {
     static fromJson(json: Record<string, unknown>): Variable;
 }
 
-interface VariableRepository {
-    getAll(params?: VariableListParams): Promise<Result<ListResult<Variable>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<Variable, ApiFailure>>;
-}
-
-declare class GetAllVariables implements UseCase<VariableListParams | undefined, ListResult<Variable>> {
-    private readonly repository;
-    constructor(repository: VariableRepository);
-    execute(params?: VariableListParams): Promise<Result<ListResult<Variable>, ApiFailure>>;
-}
-
-declare class GetVariableById implements UseCase<ViewParams, Variable> {
-    private readonly repository;
-    constructor(repository: VariableRepository);
-    execute(params: ViewParams): Promise<Result<Variable, ApiFailure>>;
+interface UseVariables {
+    fetchVariableList: (params: VariableListParams) => Promise<Result<ListResult<Variable>, ApiFailure>>;
+    fetchVariableDetail: (params: ViewParams) => Promise<Result<Variable, ApiFailure>>;
 }
+declare function useVariables(client?: StadataClient): UseVariables;
 
 declare class VerticalVariable extends BaseEntity {
     readonly id: number;
@@ -879,47 +630,68 @@ declare class VerticalVariable extends BaseEntity {
     static fromJson(json: Record<string, unknown>): VerticalVariable;
 }
 
-interface VerticalVariableRepository {
-    getAll(params: VerticalVariableListParams): Promise<Result<ListResult<VerticalVariable>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<VerticalVariable, ApiFailure>>;
+interface UseVerticalVariables {
+    fetchVerticalVariableList: (params: VerticalVariableListParams) => Promise<Result<ListResult<VerticalVariable>, ApiFailure>>;
 }
+declare function useVerticalVariables(client?: StadataClient): UseVerticalVariables;
 
-declare class GetAllVerticalVariables implements UseCase<VerticalVariableListParams, ListResult<VerticalVariable>> {
-    private readonly repository;
-    constructor(repository: VerticalVariableRepository);
-    execute(params: VerticalVariableListParams): Promise<Result<ListResult<VerticalVariable>, ApiFailure>>;
+declare class DerivedVariable extends BaseEntity {
+    readonly id: number;
+    readonly name: string;
+    readonly groupId: number;
+    readonly groupName: string;
+    constructor(id: number, name: string, groupId: number, groupName: string);
+    toJson(): Record<string, unknown>;
+    static fromJson(json: Record<string, unknown>): DerivedVariable;
 }
 
-declare class GetVerticalVariableById implements UseCase<ViewParams, VerticalVariable> {
-    private readonly repository;
-    constructor(repository: VerticalVariableRepository);
-    execute(params: ViewParams): Promise<Result<VerticalVariable, ApiFailure>>;
+interface UseDerivedVariables {
+    fetchDerivedVariableList: (params: DerivedVariableListParams) => Promise<Result<ListResult<DerivedVariable>, ApiFailure>>;
 }
+declare function useDerivedVariables(client?: StadataClient): UseDerivedVariables;
 
-declare class Unit extends BaseEntity {
+declare class Subject extends BaseEntity {
+    readonly id: number;
+    readonly name: string;
+    readonly categoryId: number;
+    readonly category: string;
+    constructor(id: number, name: string, categoryId: number, category: string);
+    toJson(): Record<string, unknown>;
+    static fromJson(json: Record<string, unknown>): Subject;
+}
+
+interface UseSubjects {
+    fetchSubjectList: (params: SubjectListParams) => Promise<Result<ListResult<Subject>, ApiFailure>>;
+    fetchSubjectDetail: (params: ViewParams) => Promise<Result<Subject, ApiFailure>>;
+}
+declare function useSubjects(client?: StadataClient): UseSubjects;
+
+declare class SubjectCategory extends BaseEntity {
     readonly id: number;
     readonly name: string;
     constructor(id: number, name: string);
     toJson(): Record<string, unknown>;
-    static fromJson(json: Record<string, unknown>): Unit;
+    static fromJson(json: Record<string, unknown>): SubjectCategory;
 }
 
-interface UnitRepository {
-    getAll(params?: UnitListParams): Promise<Result<ListResult<Unit>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<Unit, ApiFailure>>;
+interface UseSubjectCategories {
+    fetchSubjectCategoryList: (params: SubjectCategoryListParams) => Promise<Result<ListResult<SubjectCategory>, ApiFailure>>;
 }
+declare function useSubjectCategories(client?: StadataClient): UseSubjectCategories;
 
-declare class GetAllUnits implements UseCase<UnitListParams | undefined, ListResult<Unit>> {
-    private readonly repository;
-    constructor(repository: UnitRepository);
-    execute(params?: UnitListParams): Promise<Result<ListResult<Unit>, ApiFailure>>;
+declare class Unit extends BaseEntity {
+    readonly id: number;
+    readonly name: string;
+    constructor(id: number, name: string);
+    toJson(): Record<string, unknown>;
+    static fromJson(json: Record<string, unknown>): Unit;
 }
 
-declare class GetUnitById implements UseCase<ViewParams, Unit> {
-    private readonly repository;
-    constructor(repository: UnitRepository);
-    execute(params: ViewParams): Promise<Result<Unit, ApiFailure>>;
+interface UseUnits {
+    fetchUnitList: (params: UnitListParams) => Promise<Result<ListResult<Unit>, ApiFailure>>;
+    fetchUnitDetail: (params: ViewParams) => Promise<Result<Unit, ApiFailure>>;
 }
+declare function useUnits(client?: StadataClient): UseUnits;
 
 declare class Period extends BaseEntity {
     readonly id: number;
@@ -929,22 +701,10 @@ declare class Period extends BaseEntity {
     static fromJson(json: Record<string, unknown>): Period;
 }
 
-interface PeriodRepository {
-    getAll(params: PeriodListParams): Promise<Result<ListResult<Period>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<Period, ApiFailure>>;
-}
-
-declare class GetAllPeriods implements UseCase<PeriodListParams, ListResult<Period>> {
-    private readonly repository;
-    constructor(repository: PeriodRepository);
-    execute(params: PeriodListParams): Promise<Result<ListResult<Period>, ApiFailure>>;
-}
-
-declare class GetPeriodById implements UseCase<ViewParams, Period> {
-    private readonly repository;
-    constructor(repository: PeriodRepository);
-    execute(params: ViewParams): Promise<Result<Period, ApiFailure>>;
+interface UsePeriods {
+    fetchPeriodList: (params: PeriodListParams) => Promise<Result<ListResult<Period>, ApiFailure>>;
 }
+declare function usePeriods(client?: StadataClient): UsePeriods;
 
 declare class DerivedPeriod extends BaseEntity {
     readonly id: number;
@@ -956,49 +716,33 @@ declare class DerivedPeriod extends BaseEntity {
     static fromJson(json: Record<string, unknown>): DerivedPeriod;
 }
 
-interface DerivedPeriodRepository {
-    getAll(params: DerivedPeriodListParams): Promise<Result<ListResult<DerivedPeriod>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<DerivedPeriod, ApiFailure>>;
-}
-
-declare class GetAllDerivedPeriods {
-    private readonly repository;
-    constructor(repository: DerivedPeriodRepository);
-    execute(params: DerivedPeriodListParams): Promise<Result<ListResult<DerivedPeriod>, ApiFailure>>;
+interface UseDerivedPeriods {
+    fetchDerivedPeriodList: (params: DerivedPeriodListParams) => Promise<Result<ListResult<DerivedPeriod>, ApiFailure>>;
 }
+declare function useDerivedPeriods(client?: StadataClient): UseDerivedPeriods;
 
-declare class GetDerivedPeriodById {
-    private readonly repository;
-    constructor(repository: DerivedPeriodRepository);
-    execute(params: ViewParams): Promise<Result<DerivedPeriod, ApiFailure>>;
-}
-
-declare class DerivedVariable extends BaseEntity {
-    readonly id: number;
+declare class StrategicIndicator extends BaseEntity {
+    readonly variableId: number;
+    readonly indicatorId: number;
+    readonly subjectCsa: number;
+    readonly title: string;
     readonly name: string;
-    readonly groupId: number;
-    readonly groupName: string;
-    constructor(id: number, name: string, groupId: number, groupName: string);
+    readonly dataSource: string;
+    readonly value: number;
+    readonly unit: string;
+    readonly category: number;
+    readonly hashId: string;
+    readonly period: string;
+    constructor(variableId: number, indicatorId: number, subjectCsa: number, title: string, name: string, dataSource: string, value: number, unit: string, category: number, hashId: string, period: string);
     toJson(): Record<string, unknown>;
-    static fromJson(json: Record<string, unknown>): DerivedVariable;
-}
-
-interface DerivedVariableRepository {
-    getAll(params: DerivedVariableListParams): Promise<Result<ListResult<DerivedVariable>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<DerivedVariable, ApiFailure>>;
-}
-
-declare class GetAllDerivedVariables {
-    private readonly repository;
-    constructor(repository: DerivedVariableRepository);
-    execute(params: DerivedVariableListParams): Promise<Result<ListResult<DerivedVariable>, ApiFailure>>;
+    static fromJson(json: Record<string, unknown>): StrategicIndicator;
 }
 
-declare class GetDerivedVariableById {
-    private readonly repository;
-    constructor(repository: DerivedVariableRepository);
-    execute(params: ViewParams): Promise<Result<DerivedVariable, ApiFailure>>;
+interface UseStrategicIndicators {
+    fetchStrategicIndicatorList: (params: StrategicIndicatorListParams) => Promise<Result<ListResult<StrategicIndicator>, ApiFailure>>;
+    fetchStrategicIndicatorDetail: (params: ViewParams) => Promise<Result<StrategicIndicator, ApiFailure>>;
 }
+declare function useStrategicIndicators(client?: StadataClient): UseStrategicIndicators;
 
 declare class StatisticClassification extends BaseEntity {
     readonly id: string;
@@ -1008,22 +752,11 @@ declare class StatisticClassification extends BaseEntity {
     static fromJson(json: Record<string, unknown>): StatisticClassification;
 }
 
-interface StatisticClassificationRepository {
-    getAll(params?: StatisticClassificationListParams): Promise<Result<ListResult<StatisticClassification>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<StatisticClassification, ApiFailure>>;
-}
-
-declare class GetAllStatisticClassifications {
-    private readonly repository;
-    constructor(repository: StatisticClassificationRepository);
-    execute(params?: StatisticClassificationListParams): Promise<Result<ListResult<StatisticClassification>, ApiFailure>>;
-}
-
-declare class GetStatisticClassificationById {
-    private readonly repository;
-    constructor(repository: StatisticClassificationRepository);
-    execute(params: ViewParams): Promise<Result<StatisticClassification, ApiFailure>>;
+interface UseStatisticClassifications {
+    fetchStatisticClassificationList: (params: StatisticClassificationListParams) => Promise<Result<ListResult<StatisticClassification>, ApiFailure>>;
+    fetchStatisticClassificationDetail: (params: ViewParams) => Promise<Result<StatisticClassification, ApiFailure>>;
 }
+declare function useStatisticClassifications(client?: StadataClient): UseStatisticClassifications;
 
 declare class CensusCategory extends BaseEntity {
     readonly id: string;
@@ -1098,116 +831,61 @@ declare class CensusData extends BaseEntity {
     static fromJson(json: Record<string, unknown>): CensusData;
 }
 
-interface CensusRepository {
-    getAll(params?: CensusListParams): Promise<Result<ListResult<CensusEvent | CensusTopic | CensusArea | CensusDataset | CensusData>, ApiFailure>>;
-    getById(params: ViewParams): Promise<Result<CensusEvent, ApiFailure>>;
-}
-
-type CensusEntity = CensusEvent | CensusTopic | CensusArea | CensusDataset | CensusData;
-declare class GetAllCensuses implements UseCase<CensusListParams | undefined, ListResult<CensusEntity>> {
-    private repository;
-    constructor(repository: CensusRepository);
-    execute(params?: CensusListParams): Promise<Result<ListResult<CensusEntity>, ApiFailure>>;
-}
-
-declare class GetCensusById implements UseCase<ViewParams, CensusEvent> {
-    private repository;
-    constructor(repository: CensusRepository);
-    execute(params: ViewParams): Promise<Result<CensusEvent, ApiFailure>>;
+interface UseCensus {
+    fetchCensusList: (params: CensusListParams) => Promise<Result<ListResult<CensusEvent | CensusTopic | CensusArea | CensusDataset | CensusData>, ApiFailure>>;
 }
+declare function useCensus(client?: StadataClient): UseCensus;
 
-declare class VariableInfo extends BaseEntity {
-    readonly value: number;
-    readonly label: string;
-    readonly unit: string;
-    readonly subject: string;
-    readonly definition: string;
-    readonly notes: string;
-    readonly decimal?: number | undefined;
-    constructor(value: number, label: string, unit: string, subject: string, definition: string, notes: string, decimal?: number | undefined);
-    toJson(): Record<string, unknown>;
-    static fromJson(json: Record<string, unknown>): VariableInfo;
-}
-declare class VerticalVariableInfo extends BaseEntity {
-    readonly value: number | string;
-    readonly label: string;
-    constructor(value: number | string, label: string);
-    toJson(): Record<string, unknown>;
-    static fromJson(json: Record<string, unknown>): VerticalVariableInfo;
-}
-declare class PeriodInfo extends VerticalVariableInfo {
-    static fromJson(json: Record<string, unknown>): PeriodInfo;
-}
-declare class SubjectInfo extends BaseEntity {
-    readonly value: number;
-    readonly label: string;
-    constructor(value: number, label: string);
-    toJson(): Record<string, unknown>;
-    static fromJson(json: Record<string, unknown>): SubjectInfo;
-}
-declare class RelatedTable extends BaseEntity {
-    readonly id: string;
-    readonly title: string;
-    readonly tableSource: number;
-    readonly lastUpdate: string | null;
-    readonly link: string;
-    constructor(id: string, title: string, tableSource: number, lastUpdate: string | null, link: string);
-    toJson(): Record<string, unknown>;
-    static fromJson(json: Record<string, unknown>): RelatedTable;
+interface UseTrade {
+    fetchTradeData: (params: TradeParams) => Promise<Result<ResponseData<Record<string, unknown>>, ApiFailure>>;
 }
+declare function useTrade(client?: StadataClient): UseTrade;
 
-declare class DynamicTable extends BaseEntity {
-    readonly subjects: SubjectInfo[];
-    readonly variables: VariableInfo[];
-    readonly verticalVariables: VerticalVariableInfo[];
-    readonly verticalVariableLabel: string;
-    readonly periods: PeriodInfo[];
-    readonly derivedVariables: VerticalVariableInfo[];
-    readonly derivedPeriods: VerticalVariableInfo[];
-    readonly dataContent: Record<string, unknown>;
-    readonly related: RelatedTable[];
-    readonly lastUpdate?: string | null | undefined;
-    constructor(subjects: SubjectInfo[], variables: VariableInfo[], verticalVariables: VerticalVariableInfo[], verticalVariableLabel: string, periods: PeriodInfo[], derivedVariables: VerticalVariableInfo[], derivedPeriods: VerticalVariableInfo[], dataContent: Record<string, unknown>, related: RelatedTable[], lastUpdate?: string | null | undefined);
-    toJson(): Record<string, unknown>;
-    static fromJson(json: Record<string, unknown>): DynamicTable;
-    getDataValue(vervarValue: number | string, varValue: number | string, turvarValue: number | string, tahunValue: number | string, turtahunValue: number | string): unknown;
-    toStructuredData(): {
-        subject_id: number;
-        subject_label: string;
-        variable_id: number;
-        variable_label: string;
-        variable_unit: string;
-        vertical_variable_label: string;
-        last_update: string | null | undefined;
-        data: Array<{
-            id: number | string;
-            label: string;
-            data: Array<{
-                id: number | string;
-                label: string;
-                data: Array<{
-                    id: number | string;
-                    label: string;
-                    value?: unknown;
-                    data?: Array<{
-                        id: number | string;
-                        label: string;
-                        value: unknown;
-                    }>;
-                }>;
-            }>;
-        }>;
-    };
-}
-
-interface DynamicTableRepository {
-    getAll(params: DynamicTableParams): Promise<Result<DynamicTable, ApiFailure>>;
+interface StadataClientConfig {
+    apiKey: string;
+    baseURL?: string;
+    timeout?: number;
+    interceptors?: NetworkInterceptor[];
+    debug?: boolean;
+    logLevel?: LogLevel;
 }
-
-declare class GetAllDynamicTables implements UseCase<DynamicTableParams, DynamicTable> {
-    private repository;
-    constructor(repository: DynamicTableRepository);
-    execute(params: DynamicTableParams): Promise<Result<DynamicTable, ApiFailure>>;
+interface StadataClient {
+    readonly networkClient: NetworkClient;
+    readonly config: StadataClientConfig;
+}
+interface StadataClientInstance extends StadataClient {
+    useDomains: () => ReturnType<typeof useDomains>;
+    usePublications: () => ReturnType<typeof usePublications>;
+    usePressReleases: () => ReturnType<typeof usePressReleases>;
+    useStaticTables: () => ReturnType<typeof useStaticTables>;
+    useDynamicTables: () => ReturnType<typeof useDynamicTables>;
+    useInfographics: () => ReturnType<typeof useInfographics>;
+    useNews: () => ReturnType<typeof useNews>;
+    useNewsCategories: () => ReturnType<typeof useNewsCategories>;
+    useVariables: () => ReturnType<typeof useVariables>;
+    useVerticalVariables: () => ReturnType<typeof useVerticalVariables>;
+    useDerivedVariables: () => ReturnType<typeof useDerivedVariables>;
+    useSubjects: () => ReturnType<typeof useSubjects>;
+    useSubjectCategories: () => ReturnType<typeof useSubjectCategories>;
+    useUnits: () => ReturnType<typeof useUnits>;
+    usePeriods: () => ReturnType<typeof usePeriods>;
+    useDerivedPeriods: () => ReturnType<typeof useDerivedPeriods>;
+    useStrategicIndicators: () => ReturnType<typeof useStrategicIndicators>;
+    useStatisticClassifications: () => ReturnType<typeof useStatisticClassifications>;
+    useCensus: () => ReturnType<typeof useCensus>;
+    useTrade: () => ReturnType<typeof useTrade>;
+}
+declare function createStadataClient(config: StadataClientConfig): StadataClientInstance;
+
+declare function initStadata(config: StadataClientConfig): StadataClientInstance;
+declare function getGlobalClient(): StadataClientInstance;
+declare function resetGlobalClient(): void;
+
+declare class DynamicTableHtmlGenerator {
+    static generate(table: DynamicTable): string;
+    private static generateHeader;
+    private static generateBody;
+    private static formatValue;
 }
 
 interface StadataList {
@@ -1312,14 +990,4 @@ declare class Trade extends BaseEntity {
     static fromJson(json: Record<string, unknown>): Trade;
 }
 
-interface TradeRepository {
-    get(params: TradeParams): Promise<Result<ResponseData<Record<string, unknown>>, ApiFailure>>;
-}
-
-declare class GetTrade implements UseCase<TradeParams, ResponseData<Record<string, unknown>>> {
-    private repository;
-    constructor(repository: TradeRepository);
-    execute(params: TradeParams): Promise<Result<ResponseData<Record<string, unknown>>, ApiFailure>>;
-}
-
-export { ApiConstant, ApiEndpoint, ApiException, ApiFailure, ApiResponse, AuthInterceptor, BaseEntity, type BaseListParams, CancelToken, CancelledException, CancelledFailure, CensusArea, CensusCategory, CensusData, CensusDataset, CensusEvent, type CensusListParams, type CensusRepository, CensusTopic, ClassificationType, ConsoleLogPrinter, DataAvailability, DataLanguage, DateHelper, DerivedPeriod, type DerivedPeriodListParams, type DerivedPeriodRepository, DerivedVariable, type DerivedVariableListParams, type DerivedVariableRepository, Domain, type DomainListParams, type DomainRepository, DomainType, DynamicTable, type DynamicTableParams, type DynamicTableRepository, Failure, ForbiddenException, ForbiddenFailure, GetAllCensuses, GetAllDerivedPeriods, GetAllDerivedVariables, GetAllDomains, GetAllDynamicTables, GetAllInfographics, GetAllNews, GetAllNewsCategories, GetAllPeriods, GetAllPressReleases, GetAllPublications, GetAllStaticTables, GetAllStatisticClassifications, GetAllStrategicIndicators, GetAllSubjectCategories, GetAllSubjects, GetAllUnits, GetAllVariables, GetAllVerticalVariables, GetCensusById, GetDerivedPeriodById, GetDerivedVariableById, GetInfographicById, GetNewsById, GetNewsCategoryById, GetPeriodById, GetPressReleaseById, GetPublicationById, GetStaticTableById, GetStatisticClassificationById, GetStrategicIndicatorById, GetSubjectById, GetSubjectCategoryById, GetTrade, GetUnitById, GetVariableById, GetVerticalVariableById, HSCodeType, Infographic, type InfographicListParams, type InfographicRepository, Injector, type JSON, KBKILevel, KBLILevel, ListResult, type LogEntry, type LogFilter, LogLevel, type LogPrinter, Logger, LoggingInterceptor, NetworkClient, type NetworkClientConfig, NetworkException, NetworkFailure, type NetworkInterceptor, News, NewsCategory, type NewsCategoryListParams, type NewsCategoryRepository, type NewsListParams, type NewsRepository, NoParamsUseCase, NotFoundException, NotFoundFailure, Pagination, ParseFailure, Period, type PeriodListParams, type PeriodRepository, PressRelease, type PressReleaseListParams, type PressReleaseRepository, ProductionLogFilter, Publication, type PublicationListParams, type PublicationRepository, QueryParamConstant, RelatedPublication, type RequestData, type RequestOptions, type ResponseData, RetryInterceptor, ServerException, ServerFailure, StadataException, StadataJS, type StadataJSConfig, type StadataList, type StadataView, StaticTable, type StaticTableListParams, type StaticTableRepository, StatisticClassification, type StatisticClassificationListParams, type StatisticClassificationRepository, StrategicIndicator, type StrategicIndicatorListParams, type StrategicIndicatorRepository, Subject, SubjectCategory, type SubjectCategoryListParams, type SubjectCategoryRepository, type SubjectListParams, type SubjectRepository, TimeoutException, TimeoutFailure, Trade, type TradeParams, TradePeriod, type TradeRepository, TradeSource, UnauthorizedException, UnauthorizedFailure, Unit, type UnitListParams, type UnitRepository, UseCase, ValidationFailure, Variable, type VariableListParams, type VariableRepository, VerticalVariable, type VerticalVariableListParams, type VerticalVariableRepository, type ViewParams };
+export { ApiConstant, ApiEndpoint, ApiFailure, type BaseDomainListParams, type BaseListParams, CancelToken, CancelledFailure, CensusArea, CensusCategory, CensusData, CensusDataset, CensusEvent, type CensusListParams, CensusTopic, ClassificationType, DataAvailability, DataLanguage, DerivedPeriod, type DerivedPeriodListParams, DerivedVariable, type DerivedVariableListParams, Domain, type DomainListParams, DomainType, DynamicTable, DynamicTableHtmlGenerator, type DynamicTableParams, ForbiddenFailure, HSCodeType, Infographic, type InfographicListParams, type JSON, KBKILevel, KBLILevel, ListResult, LogLevel, NetworkClient, type NetworkClientConfig, NetworkFailure, type NetworkInterceptor, News, NewsCategory, type NewsCategoryListParams, type NewsListParams, NotFoundFailure, Pagination, ParseFailure, Period, type PeriodListParams, PressRelease, type PressReleaseListParams, Publication, type PublicationListParams, RelatedPublication, type RequestData, type RequestOptions, type ResponseData, ServerFailure, type StadataClient, type StadataClientConfig, type StadataClientInstance, StadataJS, type StadataJSConfig, StaticTable, type StaticTableListParams, StatisticClassification, type StatisticClassificationListParams, StrategicIndicator, type StrategicIndicatorListParams, Subject, SubjectCategory, type SubjectCategoryListParams, type SubjectListParams, TimeoutFailure, Trade, type TradeParams, TradePeriod, TradeSource, UnauthorizedFailure, Unit, type UnitListParams, type UseCensus, type UseDerivedPeriods, type UseDerivedVariables, type UseDomains, type UseDynamicTables, type UseInfographics, type UseNews, type UseNewsCategories, type UsePeriods, type UsePressReleases, type UsePublications, type UseStaticTables, type UseStatisticClassifications, type UseStrategicIndicators, type UseSubjectCategories, type UseSubjects, type UseTrade, type UseUnits, type UseVariables, type UseVerticalVariables, ValidationFailure, Variable, type VariableListParams, VerticalVariable, type VerticalVariableListParams, type ViewParams, createStadataClient, getGlobalClient, initStadata, resetGlobalClient, useCensus, useDerivedPeriods, useDerivedVariables, useDomains, useDynamicTables, useInfographics, useNews, useNewsCategories, usePeriods, usePressReleases, usePublications, useStaticTables, useStatisticClassifications, useStrategicIndicators, useSubjectCategories, useSubjects, useTrade, useUnits, useVariables, useVerticalVariables };