| Lines 1-8
          
      
      
        Link Here | 
          
            
              | 1 | import HttpClient from "./http-client"; | 1 | export class ERMAPIClient { | 
            
              | 2 |  | 2 |     constructor(HttpClient) { | 
            
              | 3 | export class ERMAPIClient extends HttpClient { | 3 |         this.httpClient = new HttpClient({ | 
            
              | 4 |     constructor() { |  |  | 
            
              | 5 |         super({ | 
        
          | 6 |             baseURL: "/api/v1/erm/", | 4 |             baseURL: "/api/v1/erm/", | 
        
          | 7 |         }); | 5 |         }); | 
        
          | 8 |     } | 6 |     } | 
  
    | Lines 10-16
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 10 |     get config() { | 8 |     get config() { | 
        
          | 11 |         return { | 9 |         return { | 
        
          | 12 |             get: () => | 10 |             get: () => | 
          
            
              | 13 |                 this.get({ | 11 |                 this.httpClient.get({ | 
        
          | 14 |                     endpoint: "config", | 12 |                     endpoint: "config", | 
        
          | 15 |                 }), | 13 |                 }), | 
        
          | 16 |         }; | 14 |         }; | 
  
    | Lines 19-25
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 19 |     get agreements() { | 17 |     get agreements() { | 
        
          | 20 |         return { | 18 |         return { | 
        
          | 21 |             get: id => | 19 |             get: id => | 
          
            
              | 22 |                 this.get({ | 20 |                 this.httpClient.get({ | 
        
          | 23 |                     endpoint: "agreements/" + id, | 21 |                     endpoint: "agreements/" + id, | 
        
          | 24 |                     headers: { | 22 |                     headers: { | 
        
          | 25 |                         "x-koha-embed": | 23 |                         "x-koha-embed": | 
  
    | Lines 27-53
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 27 |                     }, | 25 |                     }, | 
        
          | 28 |                 }), | 26 |                 }), | 
        
          | 29 |             getAll: (query, params) => | 27 |             getAll: (query, params) => | 
          
            
              | 30 |                 this.getAll({ | 28 |                 this.httpClient.getAll({ | 
        
          | 31 |                     endpoint: "agreements", | 29 |                     endpoint: "agreements", | 
        
          | 32 |                     query, | 30 |                     query, | 
        
          | 33 |                     params, | 31 |                     params, | 
        
          | 34 |                 }), | 32 |                 }), | 
        
          | 35 |             delete: id => | 33 |             delete: id => | 
          
            
              | 36 |                 this.delete({ | 34 |                 this.httpClient.delete({ | 
        
          | 37 |                     endpoint: "agreements/" + id, | 35 |                     endpoint: "agreements/" + id, | 
        
          | 38 |                 }), | 36 |                 }), | 
        
          | 39 |             create: agreement => | 37 |             create: agreement => | 
          
            
              | 40 |                 this.post({ | 38 |                 this.httpClient.post({ | 
        
          | 41 |                     endpoint: "agreements", | 39 |                     endpoint: "agreements", | 
        
          | 42 |                     body: agreement, | 40 |                     body: agreement, | 
        
          | 43 |                 }), | 41 |                 }), | 
        
          | 44 |             update: (agreement, id) => | 42 |             update: (agreement, id) => | 
          
            
              | 45 |                 this.put({ | 43 |                 this.httpClient.put({ | 
        
          | 46 |                     endpoint: "agreements/" + id, | 44 |                     endpoint: "agreements/" + id, | 
        
          | 47 |                     body: agreement, | 45 |                     body: agreement, | 
        
          | 48 |                 }), | 46 |                 }), | 
        
          | 49 |             count: (query = {}) => | 47 |             count: (query = {}) => | 
          
            
              | 50 |                 this.count({ | 48 |                 this.httpClient.count({ | 
        
          | 51 |                     endpoint: | 49 |                     endpoint: | 
        
          | 52 |                         "agreements?" + | 50 |                         "agreements?" + | 
        
          | 53 |                         new URLSearchParams({ | 51 |                         new URLSearchParams({ | 
  
    | Lines 62-68
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 62 |     get licenses() { | 60 |     get licenses() { | 
        
          | 63 |         return { | 61 |         return { | 
        
          | 64 |             get: id => | 62 |             get: id => | 
          
            
              | 65 |                 this.get({ | 63 |                 this.httpClient.get({ | 
        
          | 66 |                     endpoint: "licenses/" + id, | 64 |                     endpoint: "licenses/" + id, | 
        
          | 67 |                     headers: { | 65 |                     headers: { | 
        
          | 68 |                         "x-koha-embed": | 66 |                         "x-koha-embed": | 
  
    | Lines 70-76
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 70 |                     }, | 68 |                     }, | 
        
          | 71 |                 }), | 69 |                 }), | 
        
          | 72 |             getAll: (query, params) => | 70 |             getAll: (query, params) => | 
          
            
              | 73 |                 this.getAll({ | 71 |                 this.httpClient.getAll({ | 
        
          | 74 |                     endpoint: "licenses", | 72 |                     endpoint: "licenses", | 
        
          | 75 |                     query, | 73 |                     query, | 
        
          | 76 |                     params, | 74 |                     params, | 
  
    | Lines 79-99
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 79 |                     }, | 77 |                     }, | 
        
          | 80 |                 }), | 78 |                 }), | 
        
          | 81 |             delete: id => | 79 |             delete: id => | 
          
            
              | 82 |                 this.delete({ | 80 |                 this.httpClient.delete({ | 
        
          | 83 |                     endpoint: "licenses/" + id, | 81 |                     endpoint: "licenses/" + id, | 
        
          | 84 |                 }), | 82 |                 }), | 
        
          | 85 |             create: license => | 83 |             create: license => | 
          
            
              | 86 |                 this.post({ | 84 |                 this.httpClient.post({ | 
        
          | 87 |                     endpoint: "licenses", | 85 |                     endpoint: "licenses", | 
        
          | 88 |                     body: license, | 86 |                     body: license, | 
        
          | 89 |                 }), | 87 |                 }), | 
        
          | 90 |             update: (license, id) => | 88 |             update: (license, id) => | 
          
            
              | 91 |                 this.put({ | 89 |                 this.httpClient.put({ | 
        
          | 92 |                     endpoint: "licenses/" + id, | 90 |                     endpoint: "licenses/" + id, | 
        
          | 93 |                     body: license, | 91 |                     body: license, | 
        
          | 94 |                 }), | 92 |                 }), | 
        
          | 95 |             count: (query = {}) => | 93 |             count: (query = {}) => | 
          
            
              | 96 |                 this.count({ | 94 |                 this.httpClient.count({ | 
        
          | 97 |                     endpoint: | 95 |                     endpoint: | 
        
          | 98 |                         "licenses?" + | 96 |                         "licenses?" + | 
        
          | 99 |                         new URLSearchParams({ | 97 |                         new URLSearchParams({ | 
  
    | Lines 108-114
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 108 |     get localPackages() { | 106 |     get localPackages() { | 
        
          | 109 |         return { | 107 |         return { | 
        
          | 110 |             get: id => | 108 |             get: id => | 
          
            
              | 111 |                 this.get({ | 109 |                 this.httpClient.get({ | 
        
          | 112 |                     endpoint: "eholdings/local/packages/" + id, | 110 |                     endpoint: "eholdings/local/packages/" + id, | 
        
          | 113 |                     headers: { | 111 |                     headers: { | 
        
          | 114 |                         "x-koha-embed": | 112 |                         "x-koha-embed": | 
  
    | Lines 116-122
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 116 |                     }, | 114 |                     }, | 
        
          | 117 |                 }), | 115 |                 }), | 
        
          | 118 |             getAll: (query, params) => | 116 |             getAll: (query, params) => | 
          
            
              | 119 |                 this.getAll({ | 117 |                 this.httpClient.getAll({ | 
        
          | 120 |                     endpoint: "eholdings/local/packages", | 118 |                     endpoint: "eholdings/local/packages", | 
        
          | 121 |                     query, | 119 |                     query, | 
        
          | 122 |                     params, | 120 |                     params, | 
  
    | Lines 125-145
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 125 |                     }, | 123 |                     }, | 
        
          | 126 |                 }), | 124 |                 }), | 
        
          | 127 |             delete: id => | 125 |             delete: id => | 
          
            
              | 128 |                 this.delete({ | 126 |                 this.httpClient.delete({ | 
        
          | 129 |                     endpoint: "eholdings/local/packages/" + id, | 127 |                     endpoint: "eholdings/local/packages/" + id, | 
        
          | 130 |                 }), | 128 |                 }), | 
        
          | 131 |             create: local_package => | 129 |             create: local_package => | 
          
            
              | 132 |                 this.post({ | 130 |                 this.httpClient.post({ | 
        
          | 133 |                     endpoint: "eholdings/local/packages", | 131 |                     endpoint: "eholdings/local/packages", | 
        
          | 134 |                     body: local_package, | 132 |                     body: local_package, | 
        
          | 135 |                 }), | 133 |                 }), | 
        
          | 136 |             update: (local_package, id) => | 134 |             update: (local_package, id) => | 
          
            
              | 137 |                 this.put({ | 135 |                 this.httpClient.put({ | 
        
          | 138 |                     endpoint: "eholdings/local/packages/" + id, | 136 |                     endpoint: "eholdings/local/packages/" + id, | 
        
          | 139 |                     body: local_package, | 137 |                     body: local_package, | 
        
          | 140 |                 }), | 138 |                 }), | 
        
          | 141 |             count: (query = {}) => | 139 |             count: (query = {}) => | 
          
            
              | 142 |                 this.count({ | 140 |                 this.httpClient.count({ | 
        
          | 143 |                     endpoint: | 141 |                     endpoint: | 
        
          | 144 |                         "eholdings/local/packages?" + | 142 |                         "eholdings/local/packages?" + | 
        
          | 145 |                         new URLSearchParams({ | 143 |                         new URLSearchParams({ | 
  
    | Lines 154-181
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 154 |     get localTitles() { | 152 |     get localTitles() { | 
        
          | 155 |         return { | 153 |         return { | 
        
          | 156 |             get: id => | 154 |             get: id => | 
          
            
              | 157 |                 this.get({ | 155 |                 this.httpClient.get({ | 
        
          | 158 |                     endpoint: "eholdings/local/titles/" + id, | 156 |                     endpoint: "eholdings/local/titles/" + id, | 
        
          | 159 |                     headers: { | 157 |                     headers: { | 
        
          | 160 |                         "x-koha-embed": "resources,resources.package", | 158 |                         "x-koha-embed": "resources,resources.package", | 
        
          | 161 |                     }, | 159 |                     }, | 
        
          | 162 |                 }), | 160 |                 }), | 
        
          | 163 |             delete: id => | 161 |             delete: id => | 
          
            
              | 164 |                 this.delete({ | 162 |                 this.httpClient.delete({ | 
        
          | 165 |                     endpoint: "eholdings/local/titles/" + id, | 163 |                     endpoint: "eholdings/local/titles/" + id, | 
        
          | 166 |                 }), | 164 |                 }), | 
        
          | 167 |             create: local_package => | 165 |             create: local_package => | 
          
            
              | 168 |                 this.post({ | 166 |                 this.httpClient.post({ | 
        
          | 169 |                     endpoint: "eholdings/local/titles", | 167 |                     endpoint: "eholdings/local/titles", | 
        
          | 170 |                     body: local_package, | 168 |                     body: local_package, | 
        
          | 171 |                 }), | 169 |                 }), | 
        
          | 172 |             update: (local_package, id) => | 170 |             update: (local_package, id) => | 
          
            
              | 173 |                 this.put({ | 171 |                 this.httpClient.put({ | 
        
          | 174 |                     endpoint: "eholdings/local/titles/" + id, | 172 |                     endpoint: "eholdings/local/titles/" + id, | 
        
          | 175 |                     body: local_package, | 173 |                     body: local_package, | 
        
          | 176 |                 }), | 174 |                 }), | 
        
          | 177 |             count: (query = {}) => | 175 |             count: (query = {}) => | 
          
            
              | 178 |                 this.count({ | 176 |                 this.httpClient.count({ | 
        
          | 179 |                     endpoint: | 177 |                     endpoint: | 
        
          | 180 |                         "eholdings/local/titles?" + | 178 |                         "eholdings/local/titles?" + | 
        
          | 181 |                         new URLSearchParams({ | 179 |                         new URLSearchParams({ | 
  
    | Lines 185-196
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 185 |                         }), | 183 |                         }), | 
        
          | 186 |                 }), | 184 |                 }), | 
        
          | 187 |             import: body => | 185 |             import: body => | 
          
            
              | 188 |                 this.post({ | 186 |                 this.httpClient.post({ | 
        
          | 189 |                     endpoint: "eholdings/local/titles/import", | 187 |                     endpoint: "eholdings/local/titles/import", | 
        
          | 190 |                     body, | 188 |                     body, | 
        
          | 191 |                 }), | 189 |                 }), | 
        
          | 192 |             import_kbart: body => | 190 |             import_kbart: body => | 
          
            
              | 193 |                 this.post({ | 191 |                 this.httpClient.post({ | 
        
          | 194 |                     endpoint: "eholdings/local/titles/import_kbart", | 192 |                     endpoint: "eholdings/local/titles/import_kbart", | 
        
          | 195 |                     body, | 193 |                     body, | 
        
          | 196 |                 }), | 194 |                 }), | 
  
    | Lines 200-206
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 200 |     get localResources() { | 198 |     get localResources() { | 
        
          | 201 |         return { | 199 |         return { | 
        
          | 202 |             get: id => | 200 |             get: id => | 
          
            
              | 203 |                 this.get({ | 201 |                 this.httpClient.get({ | 
        
          | 204 |                     endpoint: "eholdings/local/resources/" + id, | 202 |                     endpoint: "eholdings/local/resources/" + id, | 
        
          | 205 |                     headers: { | 203 |                     headers: { | 
        
          | 206 |                         "x-koha-embed": "title,package,vendor", | 204 |                         "x-koha-embed": "title,package,vendor", | 
  
    | Lines 212-218
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 212 |     get EBSCOPackages() { | 210 |     get EBSCOPackages() { | 
        
          | 213 |         return { | 211 |         return { | 
        
          | 214 |             get: id => | 212 |             get: id => | 
          
            
              | 215 |                 this.get({ | 213 |                 this.httpClient.get({ | 
        
          | 216 |                     endpoint: "eholdings/ebsco/packages/" + id, | 214 |                     endpoint: "eholdings/ebsco/packages/" + id, | 
        
          | 217 |                     headers: { | 215 |                     headers: { | 
        
          | 218 |                         "x-koha-embed": | 216 |                         "x-koha-embed": | 
  
    | Lines 220-226
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 220 |                     }, | 218 |                     }, | 
        
          | 221 |                 }), | 219 |                 }), | 
        
          | 222 |             patch: (id, body) => | 220 |             patch: (id, body) => | 
          
            
              | 223 |                 this.patch({ | 221 |                 this.httpClient.patch({ | 
        
          | 224 |                     endpoint: "eholdings/ebsco/packages/" + id, | 222 |                     endpoint: "eholdings/ebsco/packages/" + id, | 
        
          | 225 |                     body, | 223 |                     body, | 
        
          | 226 |                 }), | 224 |                 }), | 
  
    | Lines 230-236
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 230 |     get EBSCOTitles() { | 228 |     get EBSCOTitles() { | 
        
          | 231 |         return { | 229 |         return { | 
        
          | 232 |             get: id => | 230 |             get: id => | 
          
            
              | 233 |                 this.get({ | 231 |                 this.httpClient.get({ | 
        
          | 234 |                     endpoint: "eholdings/ebsco/titles/" + id, | 232 |                     endpoint: "eholdings/ebsco/titles/" + id, | 
        
          | 235 |                     headers: { | 233 |                     headers: { | 
        
          | 236 |                         "x-koha-embed": "resources,resources.package", | 234 |                         "x-koha-embed": "resources,resources.package", | 
  
    | Lines 242-255
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 242 |     get EBSCOResources() { | 240 |     get EBSCOResources() { | 
        
          | 243 |         return { | 241 |         return { | 
        
          | 244 |             get: id => | 242 |             get: id => | 
          
            
              | 245 |                 this.get({ | 243 |                 this.httpClient.get({ | 
        
          | 246 |                     endpoint: "eholdings/ebsco/resources/" + id, | 244 |                     endpoint: "eholdings/ebsco/resources/" + id, | 
        
          | 247 |                     headers: { | 245 |                     headers: { | 
        
          | 248 |                         "x-koha-embed": "title,package,vendor", | 246 |                         "x-koha-embed": "title,package,vendor", | 
        
          | 249 |                     }, | 247 |                     }, | 
        
          | 250 |                 }), | 248 |                 }), | 
        
          | 251 |             patch: (id, body) => | 249 |             patch: (id, body) => | 
          
            
              | 252 |                 this.patch({ | 250 |                 this.httpClient.patch({ | 
        
          | 253 |                     endpoint: "eholdings/ebsco/resources/" + id, | 251 |                     endpoint: "eholdings/ebsco/resources/" + id, | 
        
          | 254 |                     body, | 252 |                     body, | 
        
          | 255 |                 }), | 253 |                 }), | 
  
    | Lines 259-289
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 259 |     get usage_data_providers() { | 257 |     get usage_data_providers() { | 
        
          | 260 |         return { | 258 |         return { | 
        
          | 261 |             get: id => | 259 |             get: id => | 
          
            
              | 262 |                 this.get({ | 260 |                 this.httpClient.get({ | 
        
          | 263 |                     endpoint: "usage_data_providers/" + id, | 261 |                     endpoint: "usage_data_providers/" + id, | 
        
          | 264 |                 }), | 262 |                 }), | 
        
          | 265 |             getAll: query => | 263 |             getAll: query => | 
          
            
              | 266 |                 this.getAll({ | 264 |                 this.httpClient.getAll({ | 
        
          | 267 |                     endpoint: "usage_data_providers", | 265 |                     endpoint: "usage_data_providers", | 
        
          | 268 |                     query, | 266 |                     query, | 
        
          | 269 |                     query, | 267 |                     query, | 
        
          | 270 |                 }), | 268 |                 }), | 
        
          | 271 |             delete: id => | 269 |             delete: id => | 
          
            
              | 272 |                 this.delete({ | 270 |                 this.httpClient.delete({ | 
        
          | 273 |                     endpoint: "usage_data_providers/" + id, | 271 |                     endpoint: "usage_data_providers/" + id, | 
        
          | 274 |                 }), | 272 |                 }), | 
        
          | 275 |             create: usage_data_provider => | 273 |             create: usage_data_provider => | 
          
            
              | 276 |                 this.post({ | 274 |                 this.httpClient.post({ | 
        
          | 277 |                     endpoint: "usage_data_providers", | 275 |                     endpoint: "usage_data_providers", | 
        
          | 278 |                     body: usage_data_provider, | 276 |                     body: usage_data_provider, | 
        
          | 279 |                 }), | 277 |                 }), | 
        
          | 280 |             update: (usage_data_provider, id) => | 278 |             update: (usage_data_provider, id) => | 
          
            
              | 281 |                 this.put({ | 279 |                 this.httpClient.put({ | 
        
          | 282 |                     endpoint: "usage_data_providers/" + id, | 280 |                     endpoint: "usage_data_providers/" + id, | 
        
          | 283 |                     body: usage_data_provider, | 281 |                     body: usage_data_provider, | 
        
          | 284 |                 }), | 282 |                 }), | 
        
          | 285 |             process_SUSHI_response: (id, body) => | 283 |             process_SUSHI_response: (id, body) => | 
          
            
              | 286 |                 this.post({ | 284 |                 this.httpClient.post({ | 
        
          | 287 |                     endpoint: | 285 |                     endpoint: | 
        
          | 288 |                         "usage_data_providers/" + | 286 |                         "usage_data_providers/" + | 
        
          | 289 |                         id + | 287 |                         id + | 
  
    | Lines 291-307
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 291 |                     body: body, | 289 |                     body: body, | 
        
          | 292 |                 }), | 290 |                 }), | 
        
          | 293 |             process_COUNTER_file: (id, body) => | 291 |             process_COUNTER_file: (id, body) => | 
          
            
              | 294 |                 this.post({ | 292 |                 this.httpClient.post({ | 
        
          | 295 |                     endpoint: | 293 |                     endpoint: | 
        
          | 296 |                         "usage_data_providers/" + id + "/process_COUNTER_file", | 294 |                         "usage_data_providers/" + id + "/process_COUNTER_file", | 
        
          | 297 |                     body: body, | 295 |                     body: body, | 
        
          | 298 |                 }), | 296 |                 }), | 
        
          | 299 |             test: id => | 297 |             test: id => | 
          
            
              | 300 |                 this.get({ | 298 |                 this.httpClient.get({ | 
        
          | 301 |                     endpoint: "usage_data_providers/" + id + "/test_connection", | 299 |                     endpoint: "usage_data_providers/" + id + "/test_connection", | 
        
          | 302 |                 }), | 300 |                 }), | 
        
          | 303 |             count: (query = {}) => | 301 |             count: (query = {}) => | 
          
            
              | 304 |                 this.count({ | 302 |                 this.httpClient.count({ | 
        
          | 305 |                     endpoint: | 303 |                     endpoint: | 
        
          | 306 |                         "usage_data_providers?" + | 304 |                         "usage_data_providers?" + | 
        
          | 307 |                         new URLSearchParams({ | 305 |                         new URLSearchParams({ | 
  
    | Lines 316-326
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 316 |     get counter_files() { | 314 |     get counter_files() { | 
        
          | 317 |         return { | 315 |         return { | 
        
          | 318 |             delete: id => | 316 |             delete: id => | 
          
            
              | 319 |                 this.delete({ | 317 |                 this.httpClient.delete({ | 
        
          | 320 |                     endpoint: "counter_files/" + id, | 318 |                     endpoint: "counter_files/" + id, | 
        
          | 321 |                 }), | 319 |                 }), | 
        
          | 322 |             count: (query = {}) => | 320 |             count: (query = {}) => | 
          
            
              | 323 |                 this.count({ | 321 |                 this.httpClient.count({ | 
        
          | 324 |                     endpoint: | 322 |                     endpoint: | 
        
          | 325 |                         "counter_files?" + | 323 |                         "counter_files?" + | 
        
          | 326 |                         new URLSearchParams({ | 324 |                         new URLSearchParams({ | 
  
    | Lines 335-351
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 335 |     get default_usage_reports() { | 333 |     get default_usage_reports() { | 
        
          | 336 |         return { | 334 |         return { | 
        
          | 337 |             getAll: query => | 335 |             getAll: query => | 
          
            
              | 338 |                 this.get({ | 336 |                 this.httpClient.get({ | 
        
          | 339 |                     endpoint: "default_usage_reports", | 337 |                     endpoint: "default_usage_reports", | 
        
          | 340 |                     query, | 338 |                     query, | 
        
          | 341 |                 }), | 339 |                 }), | 
        
          | 342 |             create: default_usage_report => | 340 |             create: default_usage_report => | 
          
            
              | 343 |                 this.post({ | 341 |                 this.httpClient.post({ | 
        
          | 344 |                     endpoint: "default_usage_reports", | 342 |                     endpoint: "default_usage_reports", | 
        
          | 345 |                     body: default_usage_report, | 343 |                     body: default_usage_report, | 
        
          | 346 |                 }), | 344 |                 }), | 
        
          | 347 |             delete: id => | 345 |             delete: id => | 
          
            
              | 348 |                 this.delete({ | 346 |                 this.httpClient.delete({ | 
        
          | 349 |                     endpoint: "default_usage_reports/" + id, | 347 |                     endpoint: "default_usage_reports/" + id, | 
        
          | 350 |                 }), | 348 |                 }), | 
        
          | 351 |         }; | 349 |         }; | 
  
    | Lines 354-365
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 354 |     get usage_platforms() { | 352 |     get usage_platforms() { | 
        
          | 355 |         return { | 353 |         return { | 
        
          | 356 |             getAll: query => | 354 |             getAll: query => | 
          
            
              | 357 |                 this.getAll({ | 355 |                 this.httpClient.getAll({ | 
        
          | 358 |                     endpoint: "usage_platforms", | 356 |                     endpoint: "usage_platforms", | 
        
          | 359 |                     query: query, | 357 |                     query: query, | 
        
          | 360 |                 }), | 358 |                 }), | 
        
          | 361 |             count: (query = {}) => | 359 |             count: (query = {}) => | 
          
            
              | 362 |                 this.count({ | 360 |                 this.httpClient.count({ | 
        
          | 363 |                     endpoint: | 361 |                     endpoint: | 
        
          | 364 |                         "usage_platforms?" + | 362 |                         "usage_platforms?" + | 
        
          | 365 |                         new URLSearchParams({ | 363 |                         new URLSearchParams({ | 
  
    | Lines 374-385
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 374 |     get usage_items() { | 372 |     get usage_items() { | 
        
          | 375 |         return { | 373 |         return { | 
        
          | 376 |             getAll: query => | 374 |             getAll: query => | 
          
            
              | 377 |                 this.getAll({ | 375 |                 this.httpClient.getAll({ | 
        
          | 378 |                     endpoint: "usage_items", | 376 |                     endpoint: "usage_items", | 
        
          | 379 |                     query: query, | 377 |                     query: query, | 
        
          | 380 |                 }), | 378 |                 }), | 
        
          | 381 |             count: (query = {}) => | 379 |             count: (query = {}) => | 
          
            
              | 382 |                 this.count({ | 380 |                 this.httpClient.count({ | 
        
          | 383 |                     endpoint: | 381 |                     endpoint: | 
        
          | 384 |                         "usage_items?" + | 382 |                         "usage_items?" + | 
        
          | 385 |                         new URLSearchParams({ | 383 |                         new URLSearchParams({ | 
  
    | Lines 394-405
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 394 |     get usage_databases() { | 392 |     get usage_databases() { | 
        
          | 395 |         return { | 393 |         return { | 
        
          | 396 |             getAll: query => | 394 |             getAll: query => | 
          
            
              | 397 |                 this.getAll({ | 395 |                 this.httpClient.getAll({ | 
        
          | 398 |                     endpoint: "usage_databases", | 396 |                     endpoint: "usage_databases", | 
        
          | 399 |                     query: query, | 397 |                     query: query, | 
        
          | 400 |                 }), | 398 |                 }), | 
        
          | 401 |             count: (query = {}) => | 399 |             count: (query = {}) => | 
          
            
              | 402 |                 this.count({ | 400 |                 this.httpClient.count({ | 
        
          | 403 |                     endpoint: | 401 |                     endpoint: | 
        
          | 404 |                         "usage_databases?" + | 402 |                         "usage_databases?" + | 
        
          | 405 |                         new URLSearchParams({ | 403 |                         new URLSearchParams({ | 
  
    | Lines 414-425
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 414 |     get usage_titles() { | 412 |     get usage_titles() { | 
        
          | 415 |         return { | 413 |         return { | 
        
          | 416 |             getAll: query => | 414 |             getAll: query => | 
          
            
              | 417 |                 this.getAll({ | 415 |                 this.httpClient.getAll({ | 
        
          | 418 |                     endpoint: "usage_titles", | 416 |                     endpoint: "usage_titles", | 
        
          | 419 |                     query: query, | 417 |                     query: query, | 
        
          | 420 |                 }), | 418 |                 }), | 
        
          | 421 |             count: (query = {}) => | 419 |             count: (query = {}) => | 
          
            
              | 422 |                 this.count({ | 420 |                 this.httpClient.count({ | 
        
          | 423 |                     endpoint: | 421 |                     endpoint: | 
        
          | 424 |                         "usage_titles?" + | 422 |                         "usage_titles?" + | 
        
          | 425 |                         new URLSearchParams({ | 423 |                         new URLSearchParams({ | 
  
    | Lines 434-440
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 434 |     get counter_registry() { | 432 |     get counter_registry() { | 
        
          | 435 |         return { | 433 |         return { | 
        
          | 436 |             getAll: query => | 434 |             getAll: query => | 
          
            
              | 437 |                 this.getAll({ | 435 |                 this.httpClient.getAll({ | 
        
          | 438 |                     endpoint: "counter_registry", | 436 |                     endpoint: "counter_registry", | 
        
          | 439 |                     query, | 437 |                     query, | 
        
          | 440 |                 }), | 438 |                 }), | 
  
    | Lines 443-449
          export class ERMAPIClient extends HttpClient {
      
      
        Link Here | 
        
          | 443 |     get sushi_service() { | 441 |     get sushi_service() { | 
        
          | 444 |         return { | 442 |         return { | 
        
          | 445 |             getAll: query => | 443 |             getAll: query => | 
          
            
              | 446 |                 this.getAll({ | 444 |                 this.httpClient.getAll({ | 
        
          | 447 |                     endpoint: "sushi_service", | 445 |                     endpoint: "sushi_service", | 
        
          | 448 |                     query, | 446 |                     query, | 
        
          | 449 |                 }), | 447 |                 }), |