stadata-js 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1117 @@
+import { Result } from 'neverthrow';
+
+declare abstract class Failure {
+    readonly message: string;
+    readonly code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+    toString(): string;
+    equals(other: unknown): boolean;
+}
+declare class ApiFailure extends Failure {
+    readonly statusCode?: number | undefined;
+    constructor(message: string, statusCode?: number | undefined, code?: string);
+}
+declare class CancelledFailure extends Failure {
+    constructor(message?: string);
+}
+declare class NetworkFailure extends Failure {
+    constructor(message: string);
+}
+declare class TimeoutFailure extends Failure {
+    constructor(message?: string);
+}
+declare class NotFoundFailure extends ApiFailure {
+    constructor(message?: string);
+}
+declare class UnauthorizedFailure extends ApiFailure {
+    constructor(message?: string);
+}
+declare class ForbiddenFailure extends ApiFailure {
+    constructor(message?: string);
+}
+declare class ServerFailure extends ApiFailure {
+    constructor(message?: string, statusCode?: number);
+}
+declare class ParseFailure extends Failure {
+    constructor(message: string);
+}
+declare class ValidationFailure extends Failure {
+    constructor(message: string);
+}
+
+interface NetworkInterceptor {
+    onRequest?(url: string, init: RequestInit): RequestInit | Promise<RequestInit>;
+    onResponse?(response: Response): Response | Promise<Response>;
+    onError?(error: Error): Error | Promise<Error> | null;
+}
+declare abstract class BaseNetworkInterceptor implements NetworkInterceptor {
+    onRequest?(url: string, init: RequestInit): RequestInit | Promise<RequestInit>;
+    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): RequestInit;
+    setApiKey(apiKey: string): void;
+    getApiKey(): string;
+}
+
+declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3,
+    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): RequestInit;
+    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;
+    private _isCancelled;
+    private _reason?;
+    constructor();
+    get signal(): AbortSignal;
+    get isCancelled(): boolean;
+    get reason(): string | undefined;
+    cancel(reason?: string): void;
+    throwIfCancelled(): void;
+    static create(): CancelToken;
+    static source(): {
+        token: CancelToken;
+        cancel: (reason?: string) => void;
+    };
+}
+
+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;
+    headers?: Record<string, string>;
+    interceptors?: NetworkInterceptor[];
+}
+interface RequestOptions {
+    headers?: Record<string, string>;
+    body?: unknown;
+    cancelToken?: CancelToken;
+    timeout?: number;
+}
+declare class NetworkClient {
+    private baseURL;
+    private timeout;
+    private defaultHeaders;
+    private interceptors;
+    constructor(config?: NetworkClientConfig);
+    addInterceptor(interceptor: NetworkInterceptor): void;
+    removeInterceptor(interceptor: NetworkInterceptor): void;
+    get<T>(url: string, options?: RequestOptions): Promise<Result<T, ApiFailure>>;
+    post<T>(url: string, options?: RequestOptions): Promise<Result<T, ApiFailure>>;
+    put<T>(url: string, options?: RequestOptions): Promise<Result<T, ApiFailure>>;
+    delete<T>(url: string, options?: RequestOptions): Promise<Result<T, ApiFailure>>;
+    patch<T>(url: string, options?: RequestOptions): Promise<Result<T, ApiFailure>>;
+    private request;
+    private fetchWithTimeout;
+    private combineSignals;
+    private buildUrl;
+    private handleErrorResponse;
+    private handleError;
+}
+
+interface IBaseEntity {
+    toJson(): Record<string, unknown>;
+    equals(other: unknown): boolean;
+}
+declare abstract class BaseEntity implements IBaseEntity {
+    abstract toJson(): Record<string, unknown>;
+    toString(): string;
+    equals(other: unknown): boolean;
+    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 Pagination extends BaseEntity {
+    readonly page: number;
+    readonly perPage: number;
+    readonly total: number;
+    readonly pages: number;
+    readonly count: number;
+    constructor(page: number, perPage: number, total: number, pages: number, count: number);
+    get hasNextPage(): boolean;
+    get hasPreviousPage(): boolean;
+    get nextPage(): number | null;
+    get previousPage(): number | null;
+    toJson(): Record<string, unknown>;
+    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;
+    constructor(data: T[], pagination: Pagination);
+    get hasMore(): boolean;
+    get totalItems(): number;
+    get items(): T[];
+    get itemCount(): number;
+    toJson(): Record<string, unknown>;
+    static fromJson<T>(json: Record<string, unknown>, itemFactory: (item: Record<string, unknown>) => T): ListResult<T>;
+}
+
+declare enum DataLanguage {
+    ID = "ind",
+    EN = "eng"
+}
+
+declare enum DataAvailability {
+    AVAILABLE = "available",
+    NOT_AVAILABLE = "not-available",
+    LIST_NOT_AVAILABLE = "list-not-available"
+}
+
+type JSON = Record<string, unknown>;
+interface BaseListParams {
+    domain?: string;
+    lang?: DataLanguage;
+    page?: number;
+    perPage?: number;
+    cancelToken?: CancelToken;
+}
+interface DomainListParams extends Omit<BaseListParams, 'domain'> {
+    keyword?: string;
+}
+interface PublicationListParams extends BaseListParams {
+    keyword?: string;
+    month?: number;
+    year?: number;
+}
+interface InfographicListParams extends BaseListParams {
+    keyword?: string;
+}
+interface StaticTableListParams extends BaseListParams {
+    keyword?: string;
+    month?: number;
+    year?: number;
+}
+interface NewsListParams extends BaseListParams {
+    keyword?: string;
+    month?: number;
+    year?: number;
+    newsCategoryId?: string;
+}
+interface NewsCategoryListParams extends BaseListParams {
+}
+interface PressReleaseListParams extends BaseListParams {
+    keyword?: string;
+    month?: number;
+    year?: number;
+}
+interface SubjectListParams extends BaseListParams {
+}
+interface SubjectCategoryListParams extends BaseListParams {
+}
+interface StrategicIndicatorListParams extends BaseListParams {
+}
+interface VariableListParams extends BaseListParams {
+    subjectId?: number;
+    showDeleted?: boolean;
+}
+interface VerticalVariableListParams extends BaseListParams {
+    variableId: number;
+}
+interface UnitListParams extends BaseListParams {
+}
+interface PeriodListParams extends BaseListParams {
+    variableId: number;
+}
+interface DerivedPeriodListParams extends BaseListParams {
+    variableId: number;
+}
+interface DerivedVariableListParams extends BaseListParams {
+    variableId: number;
+}
+interface DynamicTableParams extends BaseListParams {
+    tableId: string;
+    variableId: number;
+    periodId?: number;
+    derivedVariableId?: number;
+    derivedPeriodId?: number;
+}
+interface StatisticClassificationListParams extends BaseListParams {
+    keyword?: string;
+}
+interface CensusListParams extends BaseListParams {
+}
+interface ViewParams {
+    id: number | string;
+    domain: string;
+    lang?: DataLanguage;
+    cancelToken?: CancelToken;
+}
+declare enum TradeSource {
+    Export = 1,
+    Import = 2
+}
+declare enum TradePeriod {
+    Monthly = 1,
+    Annually = 2
+}
+declare enum HSCodeType {
+    TwoDigit = 1,
+    Full = 2
+}
+interface TradeParams {
+    source: TradeSource;
+    period: TradePeriod;
+    hsCode: string;
+    hsType: HSCodeType;
+    year: string;
+    cancelToken?: CancelToken;
+}
+type RequestData = Record<string, string | number | boolean | undefined>;
+type ResponseData<T> = {
+    data: T[];
+    'data-availability': string;
+    pagination?: {
+        page: number;
+        per_page: number;
+        total: number;
+        pages: number;
+        count: number;
+    };
+};
+
+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>>;
+    getById(params: ViewParams): Promise<Result<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 GetDomainById extends UseCase<ViewParams, Domain> {
+    private repository;
+    constructor(repository: DomainRepository);
+    execute(params: ViewParams): Promise<Result<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;
+}
+
+declare class RelatedPublication extends BaseEntity {
+    readonly id: string;
+    readonly title: string;
+    readonly releaseDate: Date;
+    readonly url: string;
+    readonly cover: string;
+    constructor(id: string, title: string, releaseDate: Date, url: string, cover: string);
+    toJson(): Record<string, unknown>;
+    static fromJson(json: Record<string, unknown>): RelatedPublication;
+}
+
+declare class Publication extends BaseEntity {
+    readonly id: string;
+    readonly title: string;
+    readonly issn: string;
+    readonly cover: string;
+    readonly pdf: string;
+    readonly size: string;
+    readonly scheduledDate: Date | null;
+    readonly releaseDate: Date | null;
+    readonly updateDate: Date | null;
+    readonly abstract: string | null;
+    readonly catalogueNumber: string | null;
+    readonly publicationNumber: string | null;
+    readonly relatedPublications: RelatedPublication[];
+    constructor(id: string, title: string, issn: string, cover: string, pdf: string, size: string, scheduledDate: Date | null, releaseDate: Date | null, updateDate: Date | null, abstract: string | null, catalogueNumber: string | null, publicationNumber: string | null, relatedPublications: RelatedPublication[]);
+    toJson(): Record<string, unknown>;
+    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>>;
+}
+
+declare const ApiConstant: {
+    readonly BASE_URL: "https://webapi.bps.go.id/v1/api";
+    readonly DEFAULT_TIMEOUT: 30000;
+    readonly API_VERSION: "v1";
+    readonly DEFAULT_PAGE_SIZE: 10;
+    readonly MAX_PAGE_SIZE: 100;
+};
+
+declare const ApiEndpoint: {
+    readonly DOMAIN_LIST: "/list/domain";
+    readonly DOMAIN_VIEW: "/view/domain";
+    readonly PUBLICATION_LIST: "/list/publication";
+    readonly PUBLICATION_VIEW: "/view/publication";
+    readonly INFOGRAPHIC_LIST: "/list/infographic";
+    readonly INFOGRAPHIC_VIEW: "/view/infographic";
+    readonly STATIC_TABLE_LIST: "/list/statictable";
+    readonly STATIC_TABLE_VIEW: "/view/statictable";
+    readonly NEWS_LIST: "/list/news";
+    readonly NEWS_VIEW: "/view/news";
+    readonly NEWS_CATEGORY_LIST: "/list/newscategory";
+    readonly NEWS_CATEGORY_VIEW: "/view/newscategory";
+    readonly PRESS_RELEASE_LIST: "/list/pressrelease";
+    readonly PRESS_RELEASE_VIEW: "/view/pressrelease";
+    readonly SUBJECT_LIST: "/list/subject";
+    readonly SUBJECT_VIEW: "/view/subject";
+    readonly SUBJECT_CATEGORY_LIST: "/list/subjectcat";
+    readonly SUBJECT_CATEGORY_VIEW: "/view/subjectcat";
+    readonly STRATEGIC_INDICATOR_LIST: "/list/stratind";
+    readonly STRATEGIC_INDICATOR_VIEW: "/view/stratind";
+    readonly VARIABLE_LIST: "/list/var";
+    readonly VARIABLE_VIEW: "/view/var";
+    readonly VERTICAL_VARIABLE_LIST: "/list/vervar";
+    readonly VERTICAL_VARIABLE_VIEW: "/view/vervar";
+    readonly UNIT_LIST: "/list/unit";
+    readonly UNIT_VIEW: "/view/unit";
+    readonly PERIOD_LIST: "/list/period";
+    readonly PERIOD_VIEW: "/view/period";
+    readonly DERIVED_PERIOD_LIST: "/list/turth";
+    readonly DERIVED_PERIOD_VIEW: "/view/turth";
+    readonly DERIVED_VARIABLE_LIST: "/list/turvar";
+    readonly DERIVED_VARIABLE_VIEW: "/view/turvar";
+    readonly DYNAMIC_TABLE_LIST: "/list/dynamictable";
+    readonly STATISTIC_CLASSIFICATION_LIST: "/list/kbli";
+    readonly STATISTIC_CLASSIFICATION_VIEW: "/view/kbli";
+    readonly CENSUS_LIST: "/list/sensus";
+    readonly CENSUS_VIEW: "/view/sensus";
+    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: string;
+    readonly title: string;
+    readonly abstract: string;
+    readonly releaseDate: string;
+    readonly picture: string | null;
+    constructor(id: string, title: string, abstract: string, releaseDate: string, picture: string | null);
+    toJson(): Record<string, unknown>;
+    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>>;
+}
+
+declare class StaticTable extends BaseEntity {
+    readonly id: string;
+    readonly title: string;
+    readonly subjectId: number;
+    readonly size: string;
+    readonly updatedAt: string;
+    readonly excelUrl: string;
+    constructor(id: string, title: string, subjectId: number, size: string, updatedAt: string, excelUrl: string);
+    toJson(): Record<string, unknown>;
+    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>>;
+}
+
+declare class GetStaticTableById {
+    private readonly repository;
+    constructor(repository: StaticTableRepository);
+    execute(params: ViewParams): Promise<Result<StaticTable, ApiFailure>>;
+}
+
+declare class Subject extends BaseEntity {
+    readonly id: number;
+    readonly name: string;
+    readonly categoryId: number;
+    constructor(id: number, name: string, categoryId: number);
+    toJson(): Record<string, unknown>;
+    static fromJson(json: Record<string, unknown>): Subject;
+}
+
+interface SubjectRepository {
+    getAll(params?: SubjectListParams): Promise<Result<ListResult<Subject>, ApiFailure>>;
+    getById(params: ViewParams): Promise<Result<Subject, ApiFailure>>;
+}
+
+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 GetSubjectById implements UseCase<ViewParams, Subject> {
+    private readonly repository;
+    constructor(repository: SubjectRepository);
+    execute(params: ViewParams): Promise<Result<Subject, ApiFailure>>;
+}
+
+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>): SubjectCategory;
+}
+
+interface SubjectCategoryRepository {
+    getAll(params?: SubjectCategoryListParams): Promise<Result<ListResult<SubjectCategory>, ApiFailure>>;
+    getById(params: ViewParams): Promise<Result<SubjectCategory, ApiFailure>>;
+}
+
+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 GetSubjectCategoryById implements UseCase<ViewParams, SubjectCategory> {
+    private readonly repository;
+    constructor(repository: SubjectCategoryRepository);
+    execute(params: ViewParams): Promise<Result<SubjectCategory, ApiFailure>>;
+}
+
+declare class StrategicIndicator extends BaseEntity {
+    readonly id: number;
+    readonly name: string;
+    constructor(id: number, name: string);
+    toJson(): Record<string, unknown>;
+    static fromJson(json: Record<string, unknown>): StrategicIndicator;
+}
+
+interface StrategicIndicatorRepository {
+    getAll(params?: StrategicIndicatorListParams): Promise<Result<ListResult<StrategicIndicator>, ApiFailure>>;
+    getById(params: ViewParams): Promise<Result<StrategicIndicator, ApiFailure>>;
+}
+
+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 GetStrategicIndicatorById implements UseCase<ViewParams, StrategicIndicator> {
+    private readonly repository;
+    constructor(repository: StrategicIndicatorRepository);
+    execute(params: ViewParams): Promise<Result<StrategicIndicator, ApiFailure>>;
+}
+
+declare class Variable extends BaseEntity {
+    readonly id: number;
+    readonly title: string;
+    readonly subjectId: number;
+    readonly unit: string;
+    readonly verticalVariableCount: number;
+    readonly derivedVariableCount: number;
+    readonly graph: string[];
+    constructor(id: number, title: string, subjectId: number, unit: string, verticalVariableCount: number, derivedVariableCount: number, graph: string[]);
+    toJson(): Record<string, unknown>;
+    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>>;
+}
+
+declare class VerticalVariable extends BaseEntity {
+    readonly id: number;
+    readonly variableId: number;
+    readonly label: string;
+    readonly alias: string;
+    constructor(id: number, variableId: number, label: string, alias: string);
+    toJson(): Record<string, unknown>;
+    static fromJson(json: Record<string, unknown>): VerticalVariable;
+}
+
+interface VerticalVariableRepository {
+    getAll(params: VerticalVariableListParams): Promise<Result<ListResult<VerticalVariable>, ApiFailure>>;
+    getById(params: ViewParams): Promise<Result<VerticalVariable, ApiFailure>>;
+}
+
+declare class GetAllVerticalVariables implements UseCase<VerticalVariableListParams, ListResult<VerticalVariable>> {
+    private readonly repository;
+    constructor(repository: VerticalVariableRepository);
+    execute(params: VerticalVariableListParams): Promise<Result<ListResult<VerticalVariable>, ApiFailure>>;
+}
+
+declare class GetVerticalVariableById implements UseCase<ViewParams, VerticalVariable> {
+    private readonly repository;
+    constructor(repository: VerticalVariableRepository);
+    execute(params: ViewParams): Promise<Result<VerticalVariable, 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;
+}
+
+interface UnitRepository {
+    getAll(params?: UnitListParams): Promise<Result<ListResult<Unit>, ApiFailure>>;
+    getById(params: ViewParams): Promise<Result<Unit, ApiFailure>>;
+}
+
+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 GetUnitById implements UseCase<ViewParams, Unit> {
+    private readonly repository;
+    constructor(repository: UnitRepository);
+    execute(params: ViewParams): Promise<Result<Unit, ApiFailure>>;
+}
+
+declare class Period extends BaseEntity {
+    readonly id: number;
+    readonly label: string;
+    constructor(id: number, label: string);
+    toJson(): Record<string, unknown>;
+    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>>;
+}
+
+declare class DerivedPeriod extends BaseEntity {
+    readonly id: number;
+    readonly label: string;
+    constructor(id: number, label: string);
+    toJson(): Record<string, unknown>;
+    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>>;
+}
+
+declare class GetDerivedPeriodById {
+    private readonly repository;
+    constructor(repository: DerivedPeriodRepository);
+    execute(params: ViewParams): Promise<Result<DerivedPeriod, ApiFailure>>;
+}
+
+declare class DerivedVariable extends BaseEntity {
+    readonly id: number;
+    readonly name: string;
+    constructor(id: number, name: 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>>;
+}
+
+declare class GetDerivedVariableById {
+    private readonly repository;
+    constructor(repository: DerivedVariableRepository);
+    execute(params: ViewParams): Promise<Result<DerivedVariable, ApiFailure>>;
+}
+
+declare class StatisticClassification extends BaseEntity {
+    readonly id: string;
+    readonly title: string;
+    constructor(id: string, title: string);
+    toJson(): Record<string, unknown>;
+    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>>;
+}
+
+declare class Census extends BaseEntity {
+    readonly id: number;
+    readonly activity: string;
+    readonly year: string;
+    constructor(id: number, activity: string, year: string);
+    toJson(): Record<string, unknown>;
+    static fromJson(json: Record<string, unknown>): Census;
+}
+
+interface CensusRepository {
+    getAll(params?: CensusListParams): Promise<Result<ListResult<Census>, ApiFailure>>;
+    getById(params: ViewParams): Promise<Result<Census, ApiFailure>>;
+}
+
+declare class GetAllCensuses implements UseCase<CensusListParams | undefined, ListResult<Census>> {
+    private repository;
+    constructor(repository: CensusRepository);
+    execute(params?: CensusListParams): Promise<Result<ListResult<Census>, ApiFailure>>;
+}
+
+declare class GetCensusById implements UseCase<ViewParams, Census> {
+    private repository;
+    constructor(repository: CensusRepository);
+    execute(params: ViewParams): Promise<Result<Census, ApiFailure>>;
+}
+
+declare class DynamicTable extends BaseEntity {
+    readonly variableId: number;
+    readonly title: string;
+    readonly subjectId: number;
+    readonly subjectName: string;
+    readonly notes: string;
+    readonly unit: string;
+    readonly verticalVariableId: number;
+    readonly domain: string;
+    readonly csaSubjectId?: number | undefined;
+    readonly csaSubjectName?: string | undefined;
+    readonly graphId?: number | undefined;
+    readonly graphName?: string | undefined;
+    constructor(variableId: number, title: string, subjectId: number, subjectName: string, notes: string, unit: string, verticalVariableId: number, domain: string, csaSubjectId?: number | undefined, csaSubjectName?: string | undefined, graphId?: number | undefined, graphName?: string | undefined);
+    toJson(): Record<string, unknown>;
+    static fromJson(json: Record<string, unknown>): DynamicTable;
+}
+
+interface DynamicTableRepository {
+    getAll(params: DynamicTableParams): Promise<Result<ListResult<DynamicTable>, ApiFailure>>;
+}
+
+declare class GetAllDynamicTables implements UseCase<DynamicTableParams, ListResult<DynamicTable>> {
+    private repository;
+    constructor(repository: DynamicTableRepository);
+    execute(params: DynamicTableParams): Promise<Result<ListResult<DynamicTable>, ApiFailure>>;
+}
+
+interface StadataList {
+    domains(params?: DomainListParams): Promise<Result<ListResult<Domain>, ApiFailure>>;
+    publications(params: PublicationListParams): Promise<Result<ListResult<Publication>, ApiFailure>>;
+    infographics(params: InfographicListParams): Promise<Result<ListResult<Infographic>, ApiFailure>>;
+    news(params: NewsListParams): Promise<Result<ListResult<News>, ApiFailure>>;
+    newsCategories(params?: NewsCategoryListParams): Promise<Result<ListResult<NewsCategory>, ApiFailure>>;
+    pressReleases(params: PressReleaseListParams): Promise<Result<ListResult<PressRelease>, ApiFailure>>;
+    staticTables(params: StaticTableListParams): Promise<Result<ListResult<StaticTable>, ApiFailure>>;
+    subjects(params?: SubjectListParams): Promise<Result<ListResult<Subject>, ApiFailure>>;
+    subjectCategories(params?: SubjectCategoryListParams): Promise<Result<ListResult<SubjectCategory>, ApiFailure>>;
+    strategicIndicators(params?: StrategicIndicatorListParams): Promise<Result<ListResult<StrategicIndicator>, ApiFailure>>;
+    variables(params?: VariableListParams): Promise<Result<ListResult<Variable>, ApiFailure>>;
+    verticalVariables(params: VerticalVariableListParams): Promise<Result<ListResult<VerticalVariable>, ApiFailure>>;
+    units(params?: UnitListParams): Promise<Result<ListResult<Unit>, ApiFailure>>;
+    periods(params: PeriodListParams): Promise<Result<ListResult<Period>, ApiFailure>>;
+    derivedPeriods(params: DerivedPeriodListParams): Promise<Result<ListResult<DerivedPeriod>, ApiFailure>>;
+    derivedVariables(params: DerivedVariableListParams): Promise<Result<ListResult<DerivedVariable>, ApiFailure>>;
+    statisticClassifications(params?: StatisticClassificationListParams): Promise<Result<ListResult<StatisticClassification>, ApiFailure>>;
+    censuses(params?: CensusListParams): Promise<Result<ListResult<Census>, ApiFailure>>;
+    dynamicTables(params: DynamicTableParams): Promise<Result<ListResult<DynamicTable>, ApiFailure>>;
+}
+
+interface StadataView {
+    domain(params: ViewParams): Promise<Result<Domain, ApiFailure>>;
+    publication(params: ViewParams): Promise<Result<Publication, ApiFailure>>;
+    infographic(params: ViewParams): Promise<Result<Infographic, ApiFailure>>;
+    news(params: ViewParams): Promise<Result<News, ApiFailure>>;
+    newsCategory(params: ViewParams): Promise<Result<NewsCategory, ApiFailure>>;
+    pressRelease(params: ViewParams): Promise<Result<PressRelease, ApiFailure>>;
+    staticTable(params: ViewParams): Promise<Result<StaticTable, ApiFailure>>;
+    subject(params: ViewParams): Promise<Result<Subject, ApiFailure>>;
+    subjectCategory(params: ViewParams): Promise<Result<SubjectCategory, ApiFailure>>;
+    strategicIndicator(params: ViewParams): Promise<Result<StrategicIndicator, ApiFailure>>;
+    variable(params: ViewParams): Promise<Result<Variable, ApiFailure>>;
+    verticalVariable(params: ViewParams): Promise<Result<VerticalVariable, ApiFailure>>;
+    unit(params: ViewParams): Promise<Result<Unit, ApiFailure>>;
+    period(params: ViewParams): Promise<Result<Period, ApiFailure>>;
+    derivedPeriod(params: ViewParams): Promise<Result<DerivedPeriod, ApiFailure>>;
+    derivedVariable(params: ViewParams): Promise<Result<DerivedVariable, ApiFailure>>;
+    statisticClassification(params: ViewParams): Promise<Result<StatisticClassification, ApiFailure>>;
+    census(params: ViewParams): Promise<Result<Census, ApiFailure>>;
+}
+
+interface StadataJSConfig {
+    apiKey: string;
+    baseURL?: string;
+    timeout?: number;
+    interceptors?: NetworkInterceptor[];
+    debug?: boolean;
+    logLevel?: LogLevel;
+}
+declare class StadataJS {
+    private static _instance;
+    private _list;
+    private _view;
+    private injector;
+    private networkClient;
+    private authInterceptor;
+    private logger;
+    private constructor();
+    static get instance(): StadataJS;
+    static init(config: StadataJSConfig): StadataJS;
+    static isInitialized(): boolean;
+    static destroy(): void;
+    get list(): StadataList;
+    get view(): StadataView;
+    setApiKey(apiKey: string): void;
+    addInterceptor(interceptor: NetworkInterceptor): void;
+    removeInterceptor(interceptor: NetworkInterceptor): void;
+    enableDebug(): void;
+    disableDebug(): void;
+    trade(params: TradeParams): Promise<Result<ResponseData<Record<string, unknown>>, ApiFailure>>;
+    private setupDependencies;
+    private cleanup;
+}
+
+declare class Trade extends BaseEntity {
+    readonly value: number;
+    readonly netWeight: number;
+    readonly hsCode: string;
+    readonly port: string;
+    readonly country: string;
+    readonly year: string;
+    constructor(value: number, netWeight: number, hsCode: string, port: string, country: string, year: string);
+    toJson(): Record<string, unknown>;
+    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, Census, type CensusListParams, type CensusRepository, ConsoleLogPrinter, DataAvailability, DataLanguage, DateHelper, DerivedPeriod, type DerivedPeriodListParams, type DerivedPeriodRepository, DerivedVariable, type DerivedVariableListParams, type DerivedVariableRepository, Domain, type DomainListParams, type DomainRepository, 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, GetDomainById, GetInfographicById, GetNewsById, GetNewsCategoryById, GetPeriodById, GetPressReleaseById, GetPublicationById, GetStaticTableById, GetStatisticClassificationById, GetStrategicIndicatorById, GetSubjectById, GetSubjectCategoryById, GetTrade, GetUnitById, GetVariableById, GetVerticalVariableById, HSCodeType, Infographic, type InfographicListParams, type InfographicRepository, Injector, type JSON, 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 };