@ssecd/jkn
Version:
JKN (BPJS) Bridging API untuk NodeJS
1,880 lines • 93.1 kB
TypeScript
declare module '@ssecd/jkn' {
export default class JKN extends Fetcher {
private readonly cache;
invalidateConfig(): Promise<void>;
get antrean(): Antrean;
get aplicares(): Aplicares;
get vclaim(): VClaim;
get apotek(): Apotek;
get pcare(): PCare;
get antreanFktp(): AntreanFKTP;
get icare(): ICare;
get rekamMedis(): RekamMedis;
}
type JKNResponseType<T extends Record<string, any>, K extends keyof T> = NonNullable<'response' extends keyof Awaited<ReturnType<T[K]>> ? Awaited<ReturnType<T[K]>>['response'] : never>;
type MethodParameters<T> = T extends (...args: infer P) => unknown ? P : never;
export type AntreanResponse<K extends keyof Antrean> = JKNResponseType<Antrean, K>;
export type AntreanParams<K extends keyof Antrean> = MethodParameters<Antrean[K]>;
export type VClaimResponse<T extends keyof VClaim, //
K extends keyof VClaim[T]> = JKNResponseType<VClaim[T], K>;
export type VClaimParams<T extends keyof VClaim, //
K extends keyof VClaim[T]> = MethodParameters<VClaim[T][K]>;
export type ApotekResponse<T extends keyof Apotek, //
K extends keyof Apotek[T]> = JKNResponseType<Apotek[T], K>;
export type ApotekParams<T extends keyof Apotek, //
K extends keyof Apotek[T]> = MethodParameters<Apotek[T][K]>;
export type ICareResponse<K extends keyof ICare> = JKNResponseType<ICare, K>;
export type ICareParams<K extends keyof ICare> = MethodParameters<ICare[K]>;
class AntreanFKTP extends BaseApi<'pcare'> {
protected type: "pcare";
/**
* Melihat referensi poli berdasarkan tanggal pelayanan
*/
refPoli(params: {
/** tanggal pelayanan */
tanggal: string;
}): Promise<CamelResponse<{
list: {
namapoli: string;
nmsubspesialis: string;
kdsubspesialis: string;
kodepoli: string;
}[];
} | undefined, number, unknown>>;
/**
* Melihat data dokter berdasarkan tanggal pelayanan dan poli
*/
refDokter(params: {
/** tanggal pelayanan */
tanggal: string;
/** kode poli dari referensi poli */
kodePoli: string;
}): Promise<CamelResponse<{
list: {
namadokter: string;
kodedokter: number;
jampraktek: string;
kapasitas: number;
}[];
} | undefined, number, unknown>>;
/**
* Tambah antrean baru
*/
tambah(data: {
/** nomor kartu peserta/pasien BPJS, diisi kosong jika Non-JKN/BPJS */
nomorkartu: string;
/** NIK atau nomor induk kependudukan pasien */
nik: string;
/** nomor handphone pasien */
nohp: string;
/** kode poli sub-spesialis BPJS */
kodepoli: string;
/** nama poli sesuai kode poli */
namapoli: string;
/** nomor rekam medis pasien */
norm: string;
/** tanggal periksa atau pelayanan */
tanggalperiksa: string;
/** kode dokter BPJS */
kodedokter: number;
/** nama dokter sesuai kode dokter */
namadokter: string;
/** jam praktik dokter */
jampraktek: string;
/** nomor antrean lengkap */
nomorantrean: string;
/** hanya angka urut antrean sesuai nomor antrean */
angkaantrean: number;
/** informasi untuk pasien */
keterangan: string;
}): Promise<CamelResponse<unknown, number, unknown>>;
/**
* Update status antrean untuk pernyataan hadir atau
* tidak hadir dalam pelayanan/pemeriksaan
*/
updateStatus(data: {
/** tanggal periksa atau pelayanan */
tanggalperiksa: string;
/** kode poli pelayanan dari referensi poli */
kodepoli: string;
/** nomor kartu peserta */
nomorkartu: string;
/** status antrean
*
* 1 = Hadir
*
* 2 = Tidak Hadir
*/
status: 1 | 2;
/** waktu batal dalam bentuk timestamp millisecond, misalnya: 1616559330000 */
waktu: number;
}): Promise<CamelResponse<unknown, number, unknown>>;
/**
* Batalkan antrean pasien
*/
batal(data: {
/** tanggal pelayanan atau periksa */
tanggalperiksa: string;
/** kode poli pelayanan */
kodepoli: string;
/** nomor kartu peserta */
nomorkartu: string;
/** alasan pembatalan */
alasan: string;
}): Promise<CamelResponse<unknown, number, unknown>>;
}
class Antrean extends BaseApi<'antrean'> {
protected type: "antrean";
/**
* Melihat referensi poli yang ada pada Aplikasi HFIS
*/
refPoli(): Promise<LowerResponse<{
nmpoli: string;
nmsubspesialis: string;
kdsubspesialis: string;
kdpoli: string;
}[] | undefined, number, unknown>>;
/**
* Melihat referensi dokter yang ada pada Aplikasi HFIS
*/
refDokter(): Promise<LowerResponse<{
namadokter: string;
kodedokter: number;
}[] | undefined, number, unknown>>;
/**
* Melihat referensi jadwal dokter yang ada pada Aplikasi HFIS
*/
refJadwalDokter(params: {
/** kode poli BPJS misalnya MAT untuk poli mata */
poli: string;
/** tanggal dengan format YYYY-MM-DD */
tanggal: string;
}): Promise<LowerResponse<{
kodesubspesialis: string;
hari: number;
kapasitaspasien: number;
libur: number;
namahari: string;
jadwal: string;
namasubspesialis: string;
namadokter: string;
kodepoli: string;
namapoli: string;
kodedokter: number;
}[] | undefined, number, unknown>>;
/**
* Melihat referensi poli finger print
*/
refPoliFp(): Promise<LowerResponse<{
kodesubspesialis: string;
namasubspesialis: string;
kodepoli: string;
namapoli: string;
}[] | undefined, number, unknown>>;
/**
* Melihat referensi pasien finger print
*/
refPasienFp(params: {
/** `"nik"` atau `"noka"` (Nomor kartu BPJS) */
jenis: string;
/** nomor identitas sesuai jenis */
nomor: string;
}): Promise<LowerResponse<{
nomorkartu: string;
nik: string;
tgllahir: string;
daftarfp: number;
} | undefined, number, unknown>>;
/**
* Update jadwal dokter yang ada pada Aplikasi HFIS
*
* Catatan:
* Data yang berhasil disimpan menunggu approval dari BPJS atau otomatis approve
* jadwal dokter oleh sistem, misal pengajuan perubahan jadwal oleh RS diantara
* jam 00.00 - 20.00 , kemudian alokasi approve manual oleh BPJS/cabang di jam
* 20.01-00.00. Jika pukul 00.00 belum dilakukan approval oleh kantor cabang,
* maka otomatis approve by sistem akan dilaksanakan setelah jam 00.00 dan yang
* berubah-nya esoknya (H+1).
*
* @param data data jadwal update
*/
updateJadwalDokter(data: {
/** kode poli BPJS */
kodepoli: string;
/** kode sub-spesialis BPJS */
kodesubspesialis: string;
/** kode dokter BPJS */
kodedokter: number;
jadwal: {
/**
* 1) senin
* 2) selasa
* 3) rabu
* 4) kamis
* 5) jumat
* 6) sabtu
* 7) minggu
* 8) hari libur nasional
*/
hari: string;
buka: string;
tutup: string;
}[];
}): Promise<LowerResponse<unknown, number, unknown>>;
/**
* Menambah Antrean RS
*
* @param data data antrean pasien
*/
tambah(data: {
/** kode booking antrean yang dibuat unik */
kodebooking: string;
/** JKN | NON JKN */
jenispasien: string;
/** nomor kartu pasien BPJS, diisi kosong jika NON JKN */
nomorkartu: string;
nik: string;
/** nomor handphone pasien */
nohp: string;
/** memakai kode sub-spesialis BPJS */
kodepoli: string;
namapoli: string;
/**
* 1 = Ya
*
* 0 = Tidak
*/
pasienbaru: number;
/** nomor rekam medis pasien */
norm: string;
/** tanggal periksa dengan format YYYY-MM-DD */
tanggalperiksa: string;
/** kode dokter BPJS */
kodedokter: string;
namadokter: string;
/** contoh 08:00-16:00 */
jampraktek: string;
/**
* 1 = Rujukan FKTP
*
* 2 = Rujukan Internal
*
* 3 = Kontrol
*
* 4 = Rujukan Antar RS
*/
jeniskunjungan: number;
/** nomor rujukan / kontrol pasien JKN, diisi kosong jika NON JKN */
nomorreferensi: string;
/** contoh A003 */
nomorantrean: string;
/** contoh 3 */
angkaantrean: number;
/** waktu estimasi dilayani dalam milliseconds */
estimasidilayani: number;
sisakuotajkn: number;
kuotajkn: number;
sisakuotanonjkn: number;
kuotanonjkn: number;
/** informasi untuk pasien */
keterangan: string;
}): Promise<LowerResponse<unknown, number, unknown>>;
/**
* Menambah Antrean Farmasi RS
*
* @param data data antrean pasien
*/
tambahFarmasi(data: {
kodebooking: string;
/** 'racikan' | 'non racikan' */
jenisresep: string;
nomorantrean: number;
keterangan: string;
}): Promise<LowerResponse<unknown, number, unknown>>;
/**
* Mengirimkan waktu tunggu atau waktu layan
*
* Catatan:
* - Alur Task Id Pasien Baru: 1-2-3-4-5 (apabila ada obat tambah 6-7)
* - Alur Task Id Pasien Lama: 3-4-5 (apabila ada obat tambah 6-7)
* - Sisa antrean berkurang pada task 5
* - Pemanggilan antrean poli pasien muncul pada task 4
* - Cek in / mulai waktu tunggu untuk pasien baru mulai pada task 1
* - Cek in / mulai waktu tunggu untuk pasien lama mulai pada task 3
* - Agar terdapat validasi pada sistem RS agar alur pengiriman Task Id berurutan
* dari awal, dan waktu Task Id yang kecil lebih dahulu daripada Task Id yang besar
* (misal task Id 1=08.00, task Id 2= 08.05)
* - jenisresep : Tidak ada/Racikan/Non racikan (jenisresep khusus untuk rs
* yang sudah implementasi antrean farmasi. Jika belum/tidak kolom jenisresep
* dapat dihilangkan)
*
* @param data data waktu antrean
*/
updateWaktu(data: {
/** kodebooking yang didapat dari servis tambah antrean */
kodebooking: string;
/**
* 1 = mulai waktu tunggu admisi
*
* 2 = akhir waktu tunggu admisi / mulai waktu layan admisi
*
* 3 = akhir waktu layan admisi / mulai waktu tunggu poli
*
* 4 = akhir waktu tunggu poli / mulai waktu layan poli
*
* 5 = akhir waktu layan poli / mulai waktu tunggu farmasi
*
* 6 = akhir waktu tunggu farmasi / mulai waktu layan farmasi membuat obat
*
* 7 = akhir waktu obat selesai dibuat
*
* 99 = tidak hadir / batal
*/
taskid: number;
/** waktu dalam timestamp millisecond */
waktu: number;
/** khusus yang sudah implementasi antrean farmasi */
jenisresep?: 'Tidak ada' | 'Racikan' | 'Non racikan';
}): Promise<LowerResponse<unknown, number, unknown>>;
/**
* Membatalkan antrean pasien
*
* @param data kode booking dan keterangan
*/
batal(data: {
/** kodebooking yang didapat dari servis tambah antrean */
kodebooking: string;
/** alasan pembatalan */
keterangan: string;
}): Promise<LowerResponse<unknown, number, unknown>>;
/**
* Melihat waktu task id yang telah dikirim ke BPJS
*/
listTaskId(params: {
/** kode booking yang didapat dari servis tambah antrean */
kodeBooking: string;
}): Promise<LowerResponse<{
/** contoh "16-03-2021 11:32:49 WIB" */
wakturs: string;
/** contoh "24-03-2021 12:55:23 WIB" */
waktu: string;
/** contoh "mulai waktu tunggu admisi" */
taskname: string;
taskid: number;
kodebooking: string;
}[] | undefined, number, unknown>>;
/**
* Dashboard waktu per tanggal
*
* Catatan:
* - Waktu Task 1 = Waktu tunggu admisi dalam detik
* - Waktu Task 2 = Waktu layan admisi dalam detik
* - Waktu Task 3 = Waktu tunggu poli dalam detik
* - Waktu Task 4 = Waktu layan poli dalam detik
* - Waktu Task 5 = Waktu tunggu farmasi dalam detik
* - Waktu Task 6 = Waktu layan farmasi dalam detik
* - Insertdate = Waktu pengambilan data, timestamp dalam millisecond
* - Waktu server adalah data waktu (task 1-6) yang dicatat oleh server BPJS Kesehatan
* setelah RS mengirimkan data, sedangkan waktu rs adalah data waktu (task 1-6) yang
* dikirimkan oleh RS
*/
dashboardPerTanggal(params: {
/** tanggal antrean */
tanggal: string;
/** jenis waktu (rs atau server) */
waktu: string;
}): Promise<LowerResponse<{
list: AntreanDashboard[];
} | undefined, number, unknown>>;
/**
* Dashboard waktu per bulan
*
* Catatan:
* - Waktu Task 1 = Waktu tunggu admisi dalam detik
* - Waktu Task 2 = Waktu layan admisi dalam detik
* - Waktu Task 3 = Waktu tunggu poli dalam detik
* - Waktu Task 4 = Waktu layan poli dalam detik
* - Waktu Task 5 = Waktu tunggu farmasi dalam detik
* - Waktu Task 6 = Waktu layan farmasi dalam detik
* - Insertdate = Waktu pengambilan data, timestamp dalam millisecond
* - Waktu server adalah data waktu (task 1-6) yang dicatat oleh server BPJS Kesehatan setelah
* RS mengirimkan data, sedangkan waktu rs adalah data waktu (task 1-6) yang dikirimkan oleh RS
*
* @param params parameter berupa bulan, tahun, dan jenis waktu
*/
dashboardPerBulan(params: {
/** 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 */
bulan: number;
/** contoh 2023 */
tahun: number;
/** jenis waktu (rs atau server) */
waktu: string;
}): Promise<LowerResponse<{
list: AntreanDashboard[];
} | undefined, number, unknown>>;
/**
* Melihat pendaftaran antrean per tanggal
*
* @param tanggal tanggal pendaftaran antrean
*/
perTanggal(tanggal: string): Promise<LowerResponse<AntreanDetail[] | undefined, number, unknown>>;
/**
* Melihat pendaftaran antrean per kode booking
*
* @param kodeBooking kode booking yang didapat dari servis tambah antrean
*/
perKodeBooking(kodeBooking: string): Promise<LowerResponse<AntreanDetail[] | undefined, number, unknown>>;
/**
* Melihat pendaftaran antrean belum dilayani
*/
belumDilayani(): Promise<LowerResponse<AntreanDetail[] | undefined, number, unknown>>;
/**
* Melihat pendaftaran antrean belum dilayani per poli per dokter per hari per jam praktik
*/
belumDilayaniPredikat(params: {
/** kode poli diambil dari referensi poli */
poli: string;
/** kode dokter diambil dari referensi dokter */
dokter: string;
/** hari mulai dari 1 sampai 12 */
hari: number;
/** jam praktik */
jam: string;
}): Promise<LowerResponse<AntreanDetail[] | undefined, number, unknown>>;
}
interface AntreanDetail {
/** kodebooking yang didapat dari servis tambah antrean */
kodebooking: string;
/** tanggal antrean dengan format YYYY-MM-DD */
tanggal: string;
/** kode poli BPJS */
kodepoli: string;
/** kode dokter BPJS */
kodedokter: number;
/** contoh 08:00-17:00 */
jampraktek: string;
/** NIK pasien */
nik: string;
nokapst: string;
nohp: string;
norekammedis: string;
/**
* 1 = Rujukan FKTP
*
* 2 = Rujukan Internal
*
* 3 = Kontrol
*
* 4 = Rujukan Antar RS
*/
jeniskunjungan: 1 | 2 | 3 | 4;
/** nomor rujukan / kontrol pasien JKN, diisi kosong jika NON JKN */
nomorreferensi: string;
/** contoh "Mobile JKN" */
sumberdata: string;
/**
* 1 = Ya
*
* 0 = Tidak
*/
ispeserta: 1 | 0;
noantrean: string;
/** waktu dalam timestamp millisecond */
estimasidilayani: number;
/** waktu dalam timestamp millisecond */
createdtime: number;
/** contoh "Selesai dilayani" */
status: string;
}
interface AntreanDashboard {
kdppk: string;
waktu_task1: number;
avg_waktu_task4: number;
jumlah_antrean: number;
avg_waktu_task3: number;
namapoli: string;
avg_waktu_task6: number;
avg_waktu_task5: number;
nmppk: string;
avg_waktu_task2: number;
avg_waktu_task1: number;
kodepoli: string;
waktu_task5: number;
waktu_task4: number;
waktu_task3: number;
/** waktu dalam timestamp millisecond */
insertdate: number;
/** tanggal dengan format YYYY-MM-DD */
tanggal: string;
waktu_task2: number;
waktu_task6: number;
}
class Aplicares extends BaseApi<'aplicares'> {
protected type: "aplicares";
/**
* Referensi Kamar
*/
refKamar(): Promise<LowerResponse<{
list: {
kodekelas: string;
namakelas: string;
}[];
} | undefined, number, {
totalitems: number;
} | undefined>>;
/**
* Update Ketersediaan Tempat Tidur
*
* Property `tersediapria`, `tersediawanita`, dan `tersediapriawanita`
* digunakan untuk faskes yang ingin mencantumkan informasi ketersediaan
* tempat tidur untuk pasien laki-laki, perempuan, dan laki–laki atau
* perempuan.
*/
update(data: AplicaresBedData): Promise<LowerResponse<unknown, number, unknown>>;
/**
* Buat Ruangan Baru
*
* Property `tersediapria`, `tersediawanita`, dan `tersediapriawanita`
* digunakan untuk faskes yang ingin mencantumkan informasi ketersediaan
* tempat tidur untuk pasien laki-laki, perempuan, dan laki–laki atau
* perempuan.
*/
create(data: AplicaresBedData): Promise<LowerResponse<undefined, number, unknown>>;
/**
* Melihat Data Ketersediaan Kamar Faskes
*
* Property `start` dan `limit` berfungsi untuk paging, jika faskes
* ingin menampilkan data dari baris pertama sampai baris kesepuluh
* maka `start` = `1` dan `limit` = `1`, nilai `start` dimulai dari `1`.
*/
read(params: {
/** paging start */
start: number;
/** paging limit */
limit: number;
}): Promise<LowerResponse<{
list: (AplicaresBedData & {
kodeppk: string;
rownumber: number;
lastupdate: string;
})[];
} | undefined, number, {
totalitems: number;
} | undefined>>;
/**
* Hapus Ruangan
*/
delete(data: {
/** kode kelas ruang rawat sesuai dengan mapping BPJS Kesehatan */
kodekelas: string;
/** kode ruangan faskes */
koderuang: string;
}): Promise<LowerResponse<undefined, number, unknown>>;
}
interface AplicaresBedData {
/** kode kelas ruang rawat sesuai dengan mapping BPJS Kesehatan */
kodekelas: string;
/** kode ruangan faskes */
koderuang: string;
/** nama ruang rawat faskes */
namaruang: string;
/** kapasitas ruang faskes */
kapasitas: number;
/** jumlah tempat tidur yang kosong atau dapat ditempati pasien baru */
tersedia: number;
/** jumlah tempat tidur yang kosong atau dapat ditempati pasien baru laki – laki */
tersediapria?: number;
/** jumlah tempat tidur yang kosong atau dapat ditempati pasien baru perempuan */
tersediawanita?: number;
/** jumlah tempat tidur yang kosong atau dapat ditempati pasien baru laki – laki atau perempuan */
tersediapriawanita?: number;
}
class Apotek {
private readonly cache;
private static instance;
private constructor();
static getInstance(cache: CachedApi): Apotek;
get referensi(): Referensi_1;
get obat(): Obat;
get pelayananObat(): PelayananObat;
get resep(): Resep;
get sep(): SEP_1;
get monitoring(): Monitoring_1;
}
type MaybePromise<T> = T | Promise<T>;
type Mode = 'development' | 'production';
type Type = 'aplicares' | 'vclaim' | 'antrean' | 'apotek' | 'pcare' | 'icare' | 'rekamMedis';
interface Config {
/**
* Kode PPK yang diberikan BPJS.
*
* Diperlukan untuk melakukan proses enkripsi
* pada service eRekamMedis and request pada
* service Aplicares
*
* @default process.env.JKN_PPK_CODE
*/
ppkCode: string;
/**
* Cons ID dari BPJS
*
* @default process.env.JKN_CONS_ID
*/
consId: string;
/**
* Secret key dari BPJS
*
* @default process.env.JKN_CONS_SECRET
*/
consSecret: string;
/**
* User key Aplicares dari BPJS atau gunakan user key vclaim
*
* @default process.env.JKN_VCLAIM_USER_KEY || process.env.JKN_APLICARES_USER_KEY
*/
aplicaresUserKey?: string;
/**
* User key VClaim dari BPJS
*
* @default process.env.JKN_VCLAIM_USER_KEY
*/
vclaimUserKey: string;
/**
* User key Antrean dari BPJS
*
* @default process.env.JKN_ANTREAN_USER_KEY
*/
antreanUserKey: string;
/**
* User key Apotek dari BPJS atau gunakan user key vclaim
*
* @default process.env.JKN_VCLAIM_USER_KEY || process.env.JKN_APOTEK_USER_KEY
*/
apotekUserKey?: string;
/**
* User key PCare dari BPJS
*
* @default process.env.JKN_PCARE_USER_KEY
*/
pcareUserKey: string;
/**
* User key i-Care dari BPJS
*
* Umumnya user key i-Care ini nilai sama dengan user key VClaim
* untuk FKRTL dan PCare untuk FKTP
*
* @default process.env.JKN_VCLAIM_USER_KEY || process.env.JKN_ICARE_USER_KEY
*/
icareUserKey?: string;
/**
* User key eRekam Medis dari BPJS atau gunakan user key vclaim
*
* @default process.env.JKN_VCLAIM_USER_KEY || process.env.JKN_REKAM_MEDIS_USER_KEY
*/
rekamMedisUserKey?: string;
/**
* Berupa mode "development" dan "production". Secara default akan
* membaca nilai environment variable NODE_ENV atau "development"
* jika NODE_ENV tidak terdapat nilai. Mode ini berpengaruh pada
* nilai konfigurasi yang digunakan dan JKN API base url.
*
* @default process.env.NODE_ENV || "development"
*/
mode: Mode;
/**
* Secara default bernilai `false` sehingga setiap terjadi kesalahan
* saat mengirim permintaan ke server JKN menggunakan method `send()`,
* pesan kesalahan akan dikembalikan sebagai pesan response dan log
* error akan dicetak pada konsol atau terminal. Jika bernilai true,
* maka kesalahan akan di-throw.
*
* @default false
*/
throw: boolean;
/**
* Base URL web service dari BPJS. Secara default sudah diatur
* berdasarkan base url yang ada di TrustMark. Nilai dapat diatur
* secara partial, misalnya:
*
* ```
* baseUrls: {
* vclaim: {
* development: 'http://dev.example.com',
* production: 'http://prod.example.com'
* }
* }
* ```
*/
baseUrls: Partial<Record<Type, Record<Mode, string>>>;
}
interface SendOption {
/** name of request, it helpful for log or collect stats */
name?: string;
path: `/${string}`;
method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
data?: unknown;
skipDecrypt?: boolean;
headers?: Record<string, string>;
/**
* Mengatur "Content-Type" pada request header menjadi "application/json; charset=utf-8".
* Secara default "Content-Type" pada request header adalah "application/x-www-form-urlencoded"
* meski pun saat request nilai body dalam format json. Ini tidak standar, namun mengacu pada
* panduan bridging pada halaman dokumentasi di situs TrustMark yang memaksa hal tersebut.
*
* @default undefined
*/
skipContentTypeHack?: boolean;
}
interface LowerResponse<T, C, E> {
response: T;
metadata: {
code: C;
message: string;
} & E;
}
interface CamelResponse<T, C, E> {
response: T;
metaData: {
code: C;
message: string;
} & E;
}
type SendResponse<Response, ExtraMetadata> = {
aplicares: LowerResponse<Response, number, ExtraMetadata>;
antrean: LowerResponse<Response, number, ExtraMetadata>;
vclaim: CamelResponse<Response, string, ExtraMetadata>;
apotek: CamelResponse<Response, string, ExtraMetadata>;
pcare: CamelResponse<Response, number, ExtraMetadata>;
icare: CamelResponse<Response, number, ExtraMetadata>;
rekamMedis: LowerResponse<Response, string, ExtraMetadata>;
};
class Fetcher {
private userConfig?;
onRequest: ((info: SendOption & {
type: Type;
}) => MaybePromise<void>) | undefined;
onResponse: (<T extends Type = Type>(info: SendOption & {
/** in milliseconds */ duration: number;
type: T;
}, result: SendResponse<unknown, unknown>[T]) => MaybePromise<void>) | undefined;
onError: ((error: unknown) => MaybePromise<void>) | undefined;
private configured;
private config;
constructor(userConfig?: (Partial<Config> | (() => MaybePromise<Partial<Config>>)) | undefined);
private applyConfig;
private mergeConfig;
private get userKeyMap();
private getDefaultHeaders;
private decrypt;
private decompress;
send<T extends Type, R, M>(type: T, option: SendOption): Promise<SendResponse<R | undefined, M | undefined>[T]>;
invalidateConfig(): Promise<void>;
getConfig(): Promise<Config>;
}
class ICare extends BaseApi<'icare'> {
protected type: "icare";
fkrtl(data: {
/** Nomor kartu peserta */
param: string;
/** Kode dokter */
kodedokter: number;
}): Promise<CamelResponse<{
url: string;
} | undefined, number, unknown>>;
fktp(data: {
/** Nomor kartu peserta */
param: string;
}): Promise<CamelResponse<{
url: string;
} | undefined, number, unknown>>;
}
type RequestOption = SendOption;
/**
* Implement base api directly since this is for partial support
*/
class PCare extends PCareBaseApi {
request<T>(option: RequestOption): Promise<CamelResponse<T | undefined, number, unknown>>;
}
class RekamMedis extends BaseApi<'rekamMedis'> {
protected type: "rekamMedis";
insert(data: {
/** nomor SEP */
nomorSEP: string;
/** jenis pelayanan (1 = Rawat Inap) (2 = Rawat Jalan) */
jenisPelayanan: string;
/** bulan penerbitan SEP (1 sampai 12) */
bulan: number;
/** tahun penerbitan SEP misal 2023 */
tahun: number;
/**
* data rekam medis berupa plain object
*
* Proses kompresi dan enkripsi akan dilakukan
* secara otomatis pada method ini
*/
dataRekamMedis: MRBundle;
/** log `dataMR` request data ke console atau file */
debug?: 'console' | 'file';
}): Promise<LowerResponse<{
keterangan: string;
} | undefined, string, unknown>>;
}
class VClaim {
private readonly cache;
private static instance;
private constructor();
static getInstance(cache: CachedApi): VClaim;
get lpk(): LPK;
get monitoring(): Monitoring;
get peserta(): Peserta;
get prb(): PRB;
get referensi(): Referensi;
get rencanaKontrol(): RencanaKontrol;
get rujukan(): Rujukan;
get sep(): SEP;
}
export interface Composition extends Omit<fhir4.Composition, 'section'> {
section: {
[key: string]: fhir4.CompositionSection;
};
}
export interface Patient extends fhir4.Patient {
}
export interface Encounter extends fhir4.Encounter {
subject: fhir4.Reference & {
noSep: string;
};
incomingReferral: {
identifier: fhir4.Identifier[];
}[];
reason: fhir4.CodeableConcept[];
diagnosis?: (fhir4.EncounterDiagnosis & {
condition: fhir4.Reference & {
role: fhir4.CodeableConcept;
rank: number;
};
})[] | undefined;
hospitalization: (fhir4.EncounterHospitalization & {
dischargeDisposition?: fhir4.CodeableConcept[] | undefined;
}) | undefined;
}
export interface MedicationRequest extends Omit<fhir4.MedicationRequest, 'identifier' | 'intent' | 'dosageInstruction' | 'requester'> {
identifier?: fhir4.Identifier;
intent: fhir4.MedicationRequest['intent'] | 'final';
dosageInstruction?: (Omit<fhir4.Dosage, 'timing'> & {
doseQuantity: Omit<fhir4.Quantity, 'value'> & {
value: string;
};
timing: {
repeat: {
frequency: string;
periodUnit: string;
period: number;
};
};
})[];
requester: {
agent: fhir4.Reference;
onBehalfOf: fhir4.Reference;
};
}
export interface Practitioner extends fhir4.Practitioner {
}
export interface Organization extends fhir4.Organization {
}
export interface Condition extends Omit<fhir4.Condition, 'clinicalStatus' | 'verificationStatus'> {
clinicalStatus: string;
verificationStatus: string;
}
interface Observation extends Omit<fhir4.Observation, 'performer' | 'code'> {
performer?: fhir4.Reference;
code?: {
coding: fhir4.Coding;
text: string;
};
image: {
comment: string;
link: {
reference: string;
display: string;
};
}[];
conclusion?: string;
}
export interface DiagnosticReport extends Omit<fhir4.DiagnosticReport, 'category' | 'result' | 'code'> {
subject: fhir4.Reference & {
noSep: string;
};
category?: {
coding: fhir4.Coding;
};
result?: Observation[];
code?: fhir4.CodeableConcept;
}
export interface Procedure extends fhir4.Procedure {
context: fhir4.Reference;
performer: (fhir4.ProcedurePerformer & {
role: fhir4.CodeableConcept;
})[];
}
export interface Device extends fhir4.Device {
model: string;
}
export interface MRBundle extends fhir4.Bundle<Composition | Patient | Encounter | Practitioner | Organization | Condition | Array<MedicationRequest | DiagnosticReport | Procedure | Device>> {
}
abstract class BaseApi<T extends Type = Type> {
private readonly fetcher;
protected abstract readonly type: T;
constructor(fetcher: Fetcher);
protected send<R, M = unknown>(option: SendOption): Promise<SendResponse<R | undefined, M | undefined>[T]>;
protected getConfig(): Promise<Config>;
protected requiredConfig(...keys: (keyof Config)[]): Promise<Config>;
protected get name(): string;
}
type CacheKey = `${Type}${string}`;
class CachedApi {
private readonly fetcher;
private readonly cached;
constructor(fetcher: Fetcher);
get<K extends CacheKey, V extends BaseApi>(key: K, Api: new (...args: ConstructorParameters<typeof BaseApi>) => V): V;
clear(): void;
}
class Monitoring_1 extends ApotekBaseApi {
/**
* Data klaim resep
*/
dataKlaim(params: {
/** angka bulan 1 sampai 12 */
bulan: number;
/** tahun */
tahun: number;
/** jenis obat (0 = Semua) (1 = Obat PRB) (2 = Obat Kronis Belum Stabil) (3 = Obat Kemoterapi) */
jenisObat: number;
/** status klaim (0 = Belum di-verifikasi) (1 = Sudah Verifikasi) */
status: number;
}): Promise<CamelResponse<{
rekap: {
jumlahdata: string;
totalbiayapengajuan: string;
totalbiayasetuju: string;
listsep: {
nosepapotek: string;
nosepaasal: string;
nokartu: string;
namapeserta: string;
noresep: string;
jnsobat: string;
tglpelayanan: string;
biayapengajuan: string;
biayasetuju: string;
}[];
};
} | undefined, string, unknown>>;
}
class Obat extends ApotekBaseApi {
/**
* Simpan data obat non racikan
*/
saveNonRacikan(data: {
/** nomor SEP Resep dari hasil simpan resep */
NOSJP: string;
NORESEP: string;
KDOBT: string;
NMOBAT: string;
SIGNA1OBT: number;
SIGNA2OBT: number;
JMLOBT: number;
JHO: number;
CatKhsObt: string;
}): Promise<CamelResponse<null | undefined, string, unknown>>;
/**
* Simpan data obat racikan
*/
saveRacikan(data: {
/** nomor SEP Resep dari hasil simpan resep */
NOSJP: string;
NORESEP: string;
JNSROBT: string;
KDOBT: string;
NMOBAT: string;
SIGNA1OBT: number;
SIGNA2OBT: number;
PERMINTAAN: number;
JMLOBT: number;
JHO: number;
CatKhsObt: string;
}): Promise<CamelResponse<null | undefined, string, unknown>>;
}
class PelayananObat extends ApotekBaseApi {
/**
* Hapus pelayanan obat
*/
hapus(data: {
nosepapotek: string;
noresep: string;
kodeobat: string;
tipeobat: string;
}): Promise<CamelResponse<string | undefined, string, unknown>>;
/**
* Data daftar pelayanan obat
*/
daftar(params: {
/** nomor SEP Resep dari response simpan resep */
nomorSep: string;
}): Promise<CamelResponse<{
detailsep: {
noSepApotek: string;
noSepAsal: string;
noresep: string;
nokartu: string;
nmpst: string;
kdjnsobat: string;
nmjnsobat: string;
tglpelayanan: string;
listobat: {
kodeobat: string;
namaobat: string;
tipeobat: string;
signa1: string;
signa2: string;
hari: string;
permintaan: string | null;
jumlah: string;
harga: string;
};
};
} | undefined, string, unknown>>;
/**
* Riwayat pelayanan obat
*/
riwayat(params: {
/** tanggal awal dengan format YYYY-MM-DD */
awal: string;
/** tanggal akhir dengan format YYYY-MM-DD */
akhir: string;
/** nomor kartu peserta */
nomorKartu: string;
}): Promise<CamelResponse<{
list: {
nokartu: string;
namapeserta: string;
tgllhr: string;
history: {
nosjp: string;
tglpelayanan: string;
noresep: string;
kodeobat: string;
namaobat: string;
jmlobat: string;
}[];
};
} | undefined, string, unknown>>;
}
class Referensi_1 extends ApotekBaseApi {
/**
* Daftar obat DPHO
*/
dpho(): Promise<CamelResponse<{
list: {
kodeobat: string;
namaobat: string;
prb: "True" | "False";
kronis: "True" | "False";
kemo: "True" | "False";
harga: string;
restriksi: string;
generik: string;
aktif: string | null;
}[];
} | undefined, string, unknown>>;
/**
* Daftar referensi poli
*/
poli(params: {
/** kata kunci kode atau nama poli */
keyword: string;
}): Promise<CamelResponse<{
poli: {
kode: string;
nama: string;
}[];
} | undefined, string, unknown>>;
/**
* Pencarian data fasilitas kesehatan
*/
faskes(params: {
/**
* jenis faskes
* - 1 = FKTP atau faskes tingkat 1
* - 2 = FKRTL atau faskes tingkat 2
*/
jenis: number;
/** nama atau penggalan kata dari nama faskes */
nama: string;
}): Promise<CamelResponse<{
faskes: {
kode: string;
nama: string;
}[];
} | undefined, string, unknown>>;
/**
* Pencarian setting apotek
*/
settingApotek(params: {
/** kode apotek */
kodeApotek: string;
}): Promise<CamelResponse<{
kode: string;
namaapoteker: string;
namakepala: string;
jabatankepala: string;
nipkepala: string;
siup: string;
alamat: string;
kota: string;
namaverifikator: string;
nppverifikator: string;
namapetugasapotek: string;
nippetugasapotek: string;
checkstock: "True" | "False";
} | undefined, string, unknown>>;
/**
* Data spesialistik
*/
spesialistik(): Promise<CamelResponse<{
list: {
kode: string;
nama: string;
}[];
} | undefined, string, unknown>>;
/**
* Pencarian data obat
*/
obat(param: {
/** kode jenis obat */
jenis: string;
/** tanggal resep dengan format YYYY-MM-DD */
tanggal: string;
/** filter nama obat */
filter?: string;
}): Promise<CamelResponse<{
list: {
kode: string;
nama: string;
harga: string;
}[];
} | undefined, string, unknown>>;
}
class Resep extends ApotekBaseApi {
/**
* Simpan data resep
*/
simpan(data: {
/** tanggal dan jam contoh: `"2021-08-05 18:13:11"` */
TGLSJP: string;
REFASALSJP: string;
POLIRSP: string;
/**
* (1 = Obat PRB) (2 = Obat Kronis Belum Stabil) (3 = Obat Kemoterapi)
*
* nomor Resep maksimal 5 digit, di-generate sesuai kebutuhan, dalam 1
* bulan klaim tidak boleh ada yang sama.
*/
KDJNSOBAT: string;
NORESEP: string;
IDUSERSJP: string;
/** tanggal dan jam contoh: `"2021-08-05 00:00:00"` */
TGLRSP: string;
/** tanggal dan jam contoh: `"2021-08-05 00:00:00"` */
TGLPELRSP: string;
KdDokter: string;
/** (0. Non Iterasi, 1. Iterasi) */
iterasi: string;
}): Promise<CamelResponse<{
noSep_Kunjungan: string;
noKartu: string;
nama: string;
faskesAsal: string;
/** Nomor SEP Resep */
noApotik: string;
noResep: string;
tglResep: string;
kdJnsObat: string;
byTagRsp: string;
byVerRsp: string;
tglEntry: string;
} | undefined, string, unknown>>;
/**
* Hapus data resep
*/
hapus(data: {
/** nomor SEP Resep dari response simpan resep */
nosjp: string;
/** nomor SEP Kunjungan */
refasalsjp: string;
noresep: string;
}): Promise<CamelResponse<null | undefined, string, unknown>>;
/**
* Daftar resep
*/
daftar(data: {
kdppk: string;
KdJnsObat: string;
/** TGLPELSJP | TGLRSP */
JnsTgl: string;
/** tanggal dan jam contoh: `"2019-03-01 08:49:45"` */
TglMulai: string;
/** tanggal dan jam contoh: `"2019-03-31 06:18:33"` */
TglAkhir: string;
}): Promise<CamelResponse<{
resep: {
NORESEP: string;
NOAPOTIK: string;
NOSEP_KUNJUNGAN: string;
NOKARTU: string;
NAMA: string;
TGLENTRY: string;
TGLRESEP: string;
TGLPELRSP: string;
BYTAGRSP: string;
BYVERRSP: string;
KDJNSOBAT: string;
FASKESASAL: string;
};
} | undefined, string, unknown>>;
}
class SEP_1 extends ApotekBaseApi {
/**
* Data kunjungan berdasarkan nomor SEP
*/
kunjungan(params: {
/** nomor SEP kunjungan */
nomorSep: string;
}): Promise<CamelResponse<{
noSep: string;
faskesasalresep: string;
nmfaskesasalresep: string;
nokartu: string;
namapeserta: string;
/** L atau P */
jnskelamin: string;
tgllhr: string;
pisat: string;
kdjenispeserta: string;
nmjenispeserta: string;
kodebu: string;
namabu: string;
tglsep: string;
tglplgsep: string;
jnspelayanan: string;
nmdiag: string;
poli: string;
flagprb: string;
namaprb: string;
kodedokter: string;
namadokter: string | null;
} | undefined, string, unknown>>;
}
class PCareBaseApi extends BaseApi<'pcare'> {
protected type: "pcare";
}
class LPK extends VClaimBaseApi {
/**
* Insert Rujukan
*
* @param data data LPK
*/
insert(data: DataLPK): Promise<CamelResponse<string | undefined, string, unknown>>;
/**
* Update Rujukan
*
* @param data data LPK
*/
update(data: DataLPK): Promise<CamelResponse<string | undefined, string, unknown>>;
/**
* Delete Rujukan
*/
delete(params: {
/** nomor SEP yang akan dihapus */
nomorSep: string;
}): Promise<CamelResponse<string | undefined, string, unknown>>;
/**
* Data lembar pengajuan klaim berdasarkan
* tanggal masuk dan jenis pelayanan
*/
data(params: {
/** tanggal masuk dengan format YYYY-MM-DD */
tanggal: string;
/** jenis pelayanan (1 = Rawat Inap) (2 = Rawat Jalan) */
jenis: number;
}): Promise<CamelResponse<{
lpk: {
list: {
DPJP: {
dokter: {
kode: string;
nama: string;
};
};
diagnosa: {
list: {
level: string;
list: {
kode: string;
nama: string;
};
}[];
};
jnsPelayanan: string;
noSep: string;
perawatan: {
caraKeluar: {
kode: string;
nama: string;
};
kelasRawat: {
kode: string;
nama: string;
};
kondisiPulang: {
kode: string;
nama: string;
};
ruangRawat: {
kode: string;
nama: string;
};
spesialistik: {
kode: string;
nama: string;
};
};
peserta: {
kelamin: string;
nama: string;
noKartu: string;
noMR: string;
tglLahir: string;
};
poli: {
eksekutif: string;
poli: {
kode: string;
};
};
procedure: {
list: {
list: {
kode: string;
nama: string;
};
}[];
};
rencanaTL: DataLPK["rencanaTL"] | null;
tglKeluar: string;
tglMasuk: string;
}[];
};
} | undefined, string, unknown>>;
}
interface DataLPK {
/** nomor SEP */
noSep: string;
/** tanggal dengan format YYYY-MM-DD */
tglMasuk: string;
/** tanggal dengan format YYYY-MM-DD */
tglKeluar: string;
/** penjamin: (1 = JKN) */
jaminan: string;
poli: {
/** kode poli diambil dari referensi poli */
poli: string;
};
perawatan: {
/** ruang rawat diambil dari referensi ruang rawat */
ruangRawat: string;
/** kelas rawat diambil dari referensi kelas rawat */
kelasRawat: string;
/** spesialistik diambil dari referensi spesialistik */
spesialistik: string;
/** cara keluar diambil dari referensi cara keluar */
caraKeluar: string;
/** kondisi pulang diambil dari referensi kondisi pulang */
kondisiPulang: string;
};
diagnosa: {
/** kode ICD diagnosa diambil dari referensi diagnosa */
kode: string;
/** (1 = Primer) (2 = Sekunder) */
level: string;
}[];
procedure: {
/** kode ICD prosedur diambil dari referensi prosedur/tindakan */
kode: string;
}[];
rencanaTL: {
/**
* 1) Diperbolehkan Pulang
* 2) Pemeriksaan Penunjang
* 3) Dirujuk Ke
* 4) Kontrol Kembali
*/
tindakLanjut: string;
dirujukKe: {
/** kode faskes diambil dari referensi faskes */
kodePPK: string;
};
kontrolKembali: {
/** tanggal kontrol kembali dengan format YYYY-MM-DD */
tglKontrol: string;
/** kode poli diambil dari referensi poli */
poli: string;
};
};
DPJP: string;
/** pengguna atau petugas */
user: string;
}
class Monitoring extends VClaimBaseApi {
/**
* Pencarian data kunjungan
*
* @param tanggal tanggal SEP dengan format YYYY-MM-DD
* @param jenis jenis pelayanan (1 = Rawat Inap) (2 = Rawat Jalan)
*/
kunjungan(params: {
/** tanggal SEP dengan format YYYY-MM-DD */
tanggal: string;
/** jenis pelayanan (1 = Rawat Inap) (2 = Rawat Jalan) */
jenis: number;
}): Promise<CamelResponse<{
sep: {
diagnosa: string;
jnsPelayanan: string;
kelasRawat: string;
nama: string;
noKartu: string;
noSep: string;
noRujukan: string;
poli: string | null;
tglPlgSep: string;
tglSep: string;
}[];
} | undefined, string, unknown>>;
/**
* Pencarian data klaim
*/
klaim(params: {
/** tanggal pulang dalam format YYYY-MM-DD */
tanggal: string;
/** jenis pelayanan (1 = Rawat Inap) (2 = Rawat Jalan) */
jenis: number;
/** status klaim (1 = Proses Verifikasi) (2 = Pending Verifikasi) (3 = Klaim) */
status: number;
}): Promise<CamelResponse<{
klaim: {
Inacbg: {
kode: string;
nama: string;
};
biaya: {
byPengajuan: string;
bySetujui: string;
byTarifGruper: string;
byTarifRS: string;
byTopup: string;
};
kelasRawat: string;
noFPK: string;
noSEP: string;
peserta: {
nama: string;
noKartu: string;
noMR: string;
};
poli: string;
status: string;
tglPulang: string;
tglSep: string;
}[];
} | undefined, string, unknown>>;
/**
* Pencarian history atau riwayat pelayanan per peserta
*/
riwayatPelayanan(params: {
/** nomor kartu JKN/BPJS peserta */
nomorKartu: string;
/** tanggal awal dengan format YYYY-MM-DD */
awal: string;
/** tanggal akhir dengan format YYYY-MM-DD */
akhir: string;
}): Promise<CamelResponse<{
histori: {
diagnosa: string;
jnsPelayanan: string;
kelasRawat: string;
namaPeserta: string;
noKartu: string;
noSep: string;
noRujukan: string;
poli: string;
ppkPelayanan: string;
tglPlgSep: string;
tglSep: string;
}[];
} | undefined, string, unknown>>;
/**
* Monitoring data klaim jaminan Jasa Raharja
*/
klaimJasaRaharja(params: {
/** jenis pelayanan (1 = Rawat Inap) (2 = Rawat Jalan) */
jenis: number;
/** tanggal awal dengan format YYYY-MM-DD */
awal: string;
/** tanggal akhir dengan format YYYY-MM-DD */
akhir: string;
}): Promise<CamelResponse<{
jaminan: {
sep: {
noSEP: string;
tglSEP: string;
tglPlgSEP: string;
noMr: string;
jnsPelayanan: string;
poli: string;
diagnosa: string;
peserta: {
noKartu: string;
nama: string;
noMR: string;
};
};
jasaRaharja: {
tglKejadian: string;
noRegister: string;
ketStatusDijamin: string;
ketStatusDikirim: string;
biayaDijamin: string;
plafon: string;
jmlDibayar: string;
resultsJasaRaharja: string;
};
}[];
} | undefined, string, unknown>>;
}
class Peserta extends VClaimBaseApi {
/**
* Pencarian data peserta berdasarkan nomor kartu
*/
nomorKartu(params: {
/** nomor kartu JKN atau BPJS */
nomor: string;
/** tanggal pelayanan atau SEP dengan format YYYY-MM-DD */
tanggal: string;
}): Promise<CamelResponse<{
peserta: DataPeserta;
} | undefined, string, unknown>>;
/**
* Pencarian data peserta berdasarkan NIK
*/
nomorKependudukan(params: {
/** nomor induk kependudukan atau NIK */
nomor: string;
/** tanggal pelayanan atau SEP dengan format YYYY-MM-DD */
tanggal: string;
}): Promise<CamelResponse<{
peserta: DataPeserta;
} | undefined, string, unknown>>;
}
interface DataPeserta {
cob: {
nmAsuransi: string | null;
noAsuransi: string | null;
tglTAT: string | null;
tglTMT: string | null;
};
hakKelas: {
keterangan: string;
kode: string;
};
informasi: {
dinsos: string | null;
noSKTM: string | null;
prolanisPRB: string | null;
};
jenisPeserta: {
keterangan: string;
kode: string;
};
mr: {
noMR: string | null;
noTelepon: string | null;
};
nama: string;
nik: string;
noKartu: string;
pisa: string;
provUmum: {
kdProvider: string;
nmProvider: string;
};
sex: string;
statusPeserta: {
keterangan: string;
kode: string;
};
tglCetakKartu: string;
tglLahir: string;
tglTAT: string;
tglTMT: string;
umur: {
umurSaatPelayanan: string;
umurSekarang: string;
};
}
class PRB extends VClaimBaseApi {
/**
* Insert data rujuk balik
*/
insert(data: {
/** no sep rawat jalan */
noSep: string;
/** nomor kartu peserta */
noKartu: string;
/** alamat lengkap peserta */
alamat: string;
/** alamat email */
email: string;
/** kode program PRB diambil dari referensi */
programPRB: string;
/** kode DPJP diambil dari referensi dokter */
kodeDPJP: string;
keterangan: string;
/** saran dokter pemberi rujuk balik */
saran: string;
/** pengguna atau petugas insert (harus diisi numeric) */
user: string;
obat: {
/** kode obat generik diambil dari referensi obat generik */
kdObat: string;
signa1: string;
signa2: string;
jmlObat: string;
}[];
}): Promise<CamelResponse<{
DPJP: {
kode: string;
nama: string;
};
keterangan: string;
noSRB: string;
obat: {
list: {
jmlObat: string;
nmObat: string;
signa: string;
}[];
};
peserta: {
alamat: string;
asalFaskes: {
kode: string;
nama: string;
};
email: string;
kelamin: string;
nama: string;
noKartu: string;
noTelepon: string;
tglLahir: string;
};
programPRB: string;
saran: string;
tglSRB: string;
} | undefined, string, unknown>>;
/**
* Update data rujuk balik
*/
update(data: {
/** nomor SRB (Surat Rujuk Balik) */
noSrb: string;
/** nomor SEP */
noSep: string;
/** alamat lengkap pasien */
alamat: string;
/** alamat email pasien */
email: string;
/** kode DPJP diambil dari referensi dokter */
kodeDPJP: string;
/** keterangan pasien */
keterangan: string;
/** saran dari DPJP */
saran: string;
/** pengguna atau petugas update (harus diisi numerik) */
user: string;
obat: {
/** kode obat generik diambil dari referensi obat */
kdObat: string;
signa1: string;
signa2: string;
jmlObat: string;
}[];
}): Promise<CamelResponse<string | undefined, string, unknown>>;
/**
* Hapus data rujuk balik
*/
delete(data: {
/** nomor SRB (Surat Rujuk Balik) */
noSrb: string;
/** nomor SEP */
noSep: string;
/** pengguna atau petugas hapus (harus diisi numerik) */
user: string;
}): Promise<CamelResponse<string | undefined, string, unknown>>;
/**
* Pencarian data Rujuk Balik berdasarkan nomor SRB
*/
cariByNomor(params: {
nomorSrb: string;
nomorSep: string;
}): Promise<CamelResponse<{
prb: {
DPJP: {
kode: string;
nama: string;
};
noSEP: string;
noSRB: string;
obat: {
obat: {
jmlObat: string;
kdObat: string;
nmObat: string;
signa1: string;
signa2: string;
}[];
};
peserta: {
alamat: string;
asalFaskes: {
kode: string;
nama: string;
};
email: string;
kelamin: string;
nama: string;
noKartu: string;
noTelepon: string;
tglLahir: string;
};
programPRB: {
kode: string;
nama: string;
};
keterangan: string;
saran: string;
tglSRB: string;
};
} | undefined, string, unknown>>;
/**
* Pencarian data Rujuk Balik berdasarkan tanggal SRB
*/
cariByTanggal(params: {
/** tanggal awal dengan format YYYY-MM-DD */
awal: string;
/** tanggal akhir dengan format YYYY-MM-DD */
akhir: string;
}): Promise<CamelResponse<{
prb: {
list: {
DPJP: {
kode: string;
nama: string;
};
noSEP: string;
noSRB: string;
peserta: {
alamat: string;
email: string;
nama: string;
noKartu: string;
noTelepon: string;
};
programPRB: {
kode: string;
nama: string;
};
keterangan: string;
saran: string;
tglSRB: string;
}[];
};
} | undefined, string, unknown>>;
}
class Referensi extends VClaimBaseApi {
/**
* Pencarian data diagnosa (ICD-10)
*/
diagnosa(params: {
/** kode atau nama diagnosa */
keyword: string;
}): Promise<CamelResponse<{
diagnosa: ReferensiResult[];
} | undefined, string, unknown>>;
/**
* Pencarian data poli
*/
poli(params: {
/** kode atau nama poli */
keyword: string;
}): Promise<CamelResponse<{
poli: ReferensiResult[];
} | undefined, string, unknown>>;
/**
* Pencarian data fasilitas kesehatan
*/
faskes(params: {
/** kode atau nama faskes */
keyword: string;
/** jenis faskes (1 = Faskes tingkat 1) (2 = Faskes tingkat 2) */
jenis: number;
}): Promise<CamelResponse<{
faskes: ReferensiResult[];
} | undefined, string, unknown>>;
/**
* Pencarian data dokter atau DPJP untuk pengisian DPJP Layan
*/
dpjp(params: {
/** jenis pelayanan (1 = Rawat Inap) (2 = Rawat Jalan) */
jenis: number;
/** tanggal pelayanan atau tanggal SEP dengan format YYYY-MM-DD */
tanggal: string;
/** kode spesialis atau sub-spesialis */
kode: string;
}): Promise<CamelResponse<{
list: ReferensiResult[];
} | undefined, string, unknown>>;
/**
* Daftar provinsi di Indonesia
*/
provinsi(): Promise<CamelResponse<{
list: ReferensiResult[];
} | undefined, string, unknown>>;
/**
* Daftar kabupaten di Indonesia berdasarkan kode provinsi
*/
kabupaten(params: {
/** kode provinsi */
provinsi: string;
}): Promise<CamelResponse<{
list: ReferensiResult[];
} | undefined, string, unknown>>;
/**
* Daftar kecamatan di Indonesia berdasarkan kode kabupaten
*/
kecamatan(params: {
/** kode kabupaten */
kabupaten: string;
}): Promise<CamelResponse<{
list: ReferensiResult[];
} | undefined, string, unknown