@icure/api 4.1.10 → 4.1.11

package/icc-x-api/crypto/shamir.ts

@@ -0,0 +1,328 @@
+import { utils } from './utils'
+
+export class ShamirClass {
+  // Protected settings object
+  config = {
+    bits: 8, // default number of bits
+    radix: 16, // work with HEX by default
+    size: Math.pow(2, 8 /* config.bits */),
+    max: Math.pow(2, 8 /* config.bits */) - 1,
+    minBits: 3,
+    maxBits: 16, // this permits 65,535 shares, though going this high is NOT recommended in JS!
+    bytesPerChar: 2,
+    maxBytesPerChar: 6, // Math.pow(256,7) > Math.pow(2,53)
+    // Primitive polynomials (in decimal form) for Galois Fields GF(2^n), for 2 <= n <= 30
+    // The index of each term in the array corresponds to the n for that polynomial
+    // i.e. to get the polynomial for n=16, use primitivePolynomials[16]
+    primitivePolynomials: [null, null, 1, 3, 3, 5, 3, 3, 29, 17, 9, 5, 83, 27, 43, 3, 45, 9, 39, 39, 9, 5, 3, 33, 27, 9, 71, 39, 9, 5, 83],
+    // warning for insecure PRNG
+    warning: 'WARNING:\nA secure random number generator was not found.\nUsing Math.random(), which is NOT cryptographically strong!',
+    logs: [] as Array<number>,
+    exps: [] as Array<number>,
+  }
+  private crypto: Crypto
+
+  constructor(crypto: Crypto = typeof window !== 'undefined' ? window.crypto : typeof self !== 'undefined' ? self.crypto : ({} as Crypto)) {
+    this.crypto = crypto
+  }
+
+  init() {
+    const primitive = this.config.primitivePolynomials[this.config.bits]!
+    let x = 1
+
+    for (let i = 0; i < this.config.size; i++) {
+      this.config.exps[i] = x
+      this.config.logs[x] = i
+      x <<= 1
+      if (x >= this.config.size) {
+        x ^= primitive
+        x &= this.config.max
+      }
+    }
+  }
+
+  // Splits a number string `bits`-length segments, after first
+  // optionally zero-padding it to a length that is a multiple of `padLength.
+  // Returns array of integers (each less than 2^bits-1), with each element
+  // representing a `bits`-length segment of the input string from right to left,
+  // i.e. parts[0] represents the right-most `bits`-length segment of the input string.
+  split(str: string, padLength = 0) {
+    if (padLength) {
+      str = this.padLeft(str, padLength)
+    }
+    const parts = []
+    for (var i = str.length; i > this.config.bits; i -= this.config.bits) {
+      parts.push(parseInt(str.slice(i - this.config.bits, i), 2))
+    }
+    parts.push(parseInt(str.slice(0, i), 2))
+    return parts
+  }
+
+  bin2hex(str: string) {
+    let hex = '',
+      num
+    str = this.padLeft(str, 4)
+    for (let i = str.length; i >= 4; i -= 4) {
+      num = parseInt(str.slice(i - 4, i), 2)
+      if (isNaN(num)) {
+        throw new Error('Invalid binary character.')
+      }
+      hex = num.toString(16) + hex
+    }
+    return hex
+  }
+
+  hex2bin(str: string) {
+    let bin = '',
+      num
+    for (let i = str.length - 1; i >= 0; i--) {
+      num = parseInt(str[i], 16)
+      if (isNaN(num)) {
+        throw new Error('Invalid hex character.')
+      }
+      bin = this.padLeft(num.toString(2), 4) + bin
+    }
+
+    return bin
+  }
+
+  padLeft(str: string, bits: number = this.config.bits) {
+    const missing = str.length % bits
+    return (missing ? new Array(bits - missing + 1).join('0') : '') + str
+  }
+
+  random(bits: number) {
+    const construct = (bits: number, arr: Uint32Array, size: number) => {
+      let str = '',
+        i = 0
+      const len = arr.length - 1
+      while (i < len || str.length < bits) {
+        str += this.padLeft(arr[i].toString(16), size)
+        i++
+      }
+      str = str.substr(-bits / 4)
+      return (str.match(/0/g) || []).length === str.length ? null : str
+    }
+
+    let elems = Math.ceil(bits / 32),
+      str = null,
+      arr = new Uint32Array(elems)
+
+    while (str === null) {
+      crypto.getRandomValues(arr)
+      str = construct(bits, arr, 8)
+    }
+
+    return str
+  }
+
+  share(secretString: string, numShares: number, threshold: number) {
+    if (!this.config.logs.length) {
+      this.init()
+    }
+
+    if (numShares % 1 !== 0 || numShares < 2) {
+      throw new Error('Number of shares must be an integer between 2 and 2^bits-1 (' + this.config.max + '), inclusive.')
+    }
+    if (numShares > this.config.max) {
+      var neededBits = Math.ceil(Math.log(numShares + 1) / Math.LN2)
+      throw new Error(
+        'Number of shares must be an integer between 2 and 2^bits-1 (' +
+          this.config.max +
+          '), inclusive. To create ' +
+          numShares +
+          ' shares, use at least ' +
+          neededBits +
+          ' bits.'
+      )
+    }
+    if (threshold % 1 !== 0 || threshold < 2) {
+      throw new Error('Threshold number of shares must be an integer between 2 and 2^bits-1 (' + this.config.max + '), inclusive.')
+    }
+    if (threshold > this.config.max) {
+      var neededBits = Math.ceil(Math.log(threshold + 1) / Math.LN2)
+      throw new Error(
+        'Threshold number of shares must be an integer between 2 and 2^bits-1 (' +
+          this.config.max +
+          '), inclusive.  To use a threshold of ' +
+          threshold +
+          ', use at least ' +
+          neededBits +
+          ' bits.'
+      )
+    }
+
+    // append a 1 so that we can preserve the correct number of leading zeros in our secret
+    const secret = this.split('1' + this.hex2bin(secretString), 0)
+    const x = new Array(numShares),
+      y = new Array(numShares)
+    for (let i = 0, len = secret.length; i < len; i++) {
+      const subShares = this._getShares(secret[i], numShares, threshold)
+      for (let j = 0; j < numShares; j++) {
+        x[j] = x[j] || subShares[j].x.toString(this.config.radix)
+        y[j] = this.padLeft(subShares[j].y.toString(2)) + (y[j] ? y[j] : '')
+      }
+    }
+    const padding = this.config.max.toString(this.config.radix).length
+    return y.map((b, idx) => this.config.bits.toString(16).toUpperCase() + this.padLeft(x[idx], padding) + this.bin2hex(b))
+  }
+
+  // This is the basic polynomial generation and evaluation function
+  // for a `config.bits`-length secret (NOT an arbitrary length)
+  // Note: no error-checking at this stage! If `secrets` is NOT
+  // a NUMBER less than 2^bits-1, the output will be incorrect!
+  _getShares(secret: number, numShares: number, threshold: number) {
+    const shares = []
+    const coeffs = [secret]
+
+    for (var i = 1; i < threshold; i++) {
+      coeffs[i] = parseInt(this.random(this.config.bits), 16)
+    }
+    for (var i = 1, len = numShares + 1; i < len; i++) {
+      shares[i - 1] = {
+        x: i,
+        y: this.horner(i, coeffs),
+      }
+    }
+    return shares
+  }
+
+  // Polynomial evaluation at `x` using Horner's Method
+  // TODO: this can possibly be sped up using other methods
+  // NOTE: fx=fx * x + coeff[i] ->  exp(log(fx) + log(x)) + coeff[i],
+  //       so if fx===0, just set fx to coeff[i] because
+  //       using the exp/log form will result in incorrect value
+  horner(x: number, coeffs: Array<number>) {
+    const logx = this.config.logs[x]
+    let fx = 0
+    for (let i = coeffs.length - 1; i >= 0; i--) {
+      if (fx === 0) {
+        fx = coeffs[i]
+        continue
+      }
+      fx = this.config.exps[(logx + this.config.logs[fx]) % this.config.max] ^ coeffs[i]
+    }
+    return fx
+  }
+
+  processShare(share: string) {
+    const bits = parseInt(share[0], 16)
+    if (bits && (bits % 1 !== 0 || bits < this.config.minBits || bits > this.config.maxBits)) {
+      throw new Error('Number of bits must be an integer between ' + this.config.minBits + ' and ' + this.config.maxBits + ', inclusive.')
+    }
+
+    const max = Math.pow(2, bits) - 1
+    const idLength = max.toString(this.config.radix).length
+
+    const id = parseInt(share.substr(1, idLength), this.config.radix)
+    if (id % 1 !== 0 || id < 1 || id > max) {
+      throw new Error('Share id must be an integer between 1 and ' + this.config.max + ', inclusive.')
+    }
+    share = share.substr(idLength + 1)
+    if (!share.length) {
+      throw new Error('Invalid share: zero-length share.')
+    }
+    return {
+      bits: bits,
+      id: id,
+      value: share,
+    }
+  }
+
+  _combine(at: number, shares: Array<string>) {
+    if (!this.config.logs.length) {
+      this.init()
+    }
+
+    const x: Array<number> = []
+    const y: Array<Array<number>> = []
+    let result = ''
+    let idx: number
+
+    for (var i = 0, len = shares.length; i < len; i++) {
+      const share = this.processShare(shares[i])
+
+      if (x.includes(share['id'])) {
+        // repeated x value?
+        continue
+      }
+
+      idx = x.push(share['id']) - 1
+      const shareValues = this.split(this.hex2bin(share['value']))
+      for (let j = 0, len2 = shareValues.length; j < len2; j++) {
+        y[j] = y[j] || []
+        y[j][idx] = shareValues[j]
+      }
+    }
+
+    for (var i = 0, len = y.length; i < len; i++) {
+      result = this.padLeft(this.lagrange(at, x, y[i]).toString(2)) + result
+    }
+
+    if (at === 0) {
+      // reconstructing the secret
+      return this.bin2hex(result.slice(result.indexOf('1') + 1))
+    } else {
+      // generating a new share
+      return this.bin2hex(result)
+    }
+  }
+
+  combine(shares: Array<string>) {
+    return this._combine(0, shares)
+  }
+
+  // Generate a new share with id `id` (a number between 1 and 2^bits-1)
+  // `id` can be a Number or a String in the default radix (16)
+  newShare(id: number | string, shares: Array<string>) {
+    if (typeof id === 'string') {
+      id = parseInt(id, this.config.radix)
+    }
+
+    const share = this.processShare(shares[0])
+    const max = Math.pow(2, share['bits']) - 1
+
+    if (id % 1 !== 0 || id < 1 || id > max) {
+      throw new Error('Share id must be an integer between 1 and ' + this.config.max + ', inclusive.')
+    }
+
+    const padding = max.toString(this.config.radix).length
+    return this.config.bits.toString(16).toUpperCase() + this.padLeft(id.toString(this.config.radix), padding) + this._combine(id, shares)
+  }
+
+  // Evaluate the Lagrange interpolation polynomial at x = `at`
+  // using x and y Arrays that are of the same length, with
+  // corresponding elements constituting points on the polynomial.
+  lagrange(at: number, x: Array<number>, y: Array<number>) {
+    let sum = 0,
+      product,
+      i,
+      j,
+      len
+    for (i = 0, len = x.length; i < len; i++) {
+      if (!y[i]) {
+        continue
+      }
+
+      product = this.config.logs[y[i]]
+      for (j = 0; j < len; j++) {
+        if (i === j) {
+          continue
+        }
+        if (at === x[j]) {
+          // happens when computing a share that is in the list of shares used to compute it
+          product = -1 // fix for a zero product term, after which the sum should be sum^0 = sum, not sum^1
+          break
+        }
+        product =
+          (product + this.config.logs[at ^ x[j]] - this.config.logs[x[i] ^ x[j]] + this.config.max) /* to make sure it's not negative */ %
+          this.config.max
+      }
+
+      sum = product === -1 ? sum : sum ^ this.config.exps[product] // though exps[-1]= undefined and undefined ^ anything = anything in chrome, this behavior may not hold everywhere, so do the check
+    }
+    return sum
+  }
+}
+
+export const shamir = new ShamirClass()

package/icc-x-api/crypto/utils.ts

@@ -0,0 +1,241 @@
+import * as moment from 'moment'
+import { Moment } from 'moment'
+import * as _ from 'lodash'
+import { a2b, b2a, b64Url2ua, string2ua, ua2b64Url, ua2hex, ua2string } from '../utils/binary-utils'
+import { pack } from '../utils/asn1-packer'
+import { parseAsn1 } from '../utils/asn1-parser'
+
+export class UtilsClass {
+  constructor() {}
+
+  notConcurrent<T>(concurrencyMap: { [key: string]: PromiseLike<T> }, key: string, proc: () => PromiseLike<T>): PromiseLike<T> {
+    const inFlight = concurrencyMap[key]
+    if (!inFlight) {
+      return (concurrencyMap[key] = (async () => {
+        try {
+          return await proc()
+        } finally {
+          delete concurrencyMap[key]
+        }
+      })())
+    } else {
+      return concurrencyMap[key].then(() => this.notConcurrent(concurrencyMap, key, proc))
+    }
+  }
+
+  jwk2pkcs8(jwk: any): string {
+    return pack([
+      0x30,
+      [
+        [0x02, '00'],
+        [0x30, [[0x06, '2a864886f70d010101'], [0x05]]],
+        [
+          0x04,
+          [
+            [
+              0x30,
+              [
+                [0x02, '00'],
+                [0x02, ua2hex(b64Url2ua(jwk.n))],
+                [0x02, ua2hex(b64Url2ua(jwk.e))],
+                [0x02, ua2hex(b64Url2ua(jwk.d))],
+                [0x02, ua2hex(b64Url2ua(jwk.p))],
+                [0x02, ua2hex(b64Url2ua(jwk.q))],
+                [0x02, ua2hex(b64Url2ua(jwk.dp))],
+                [0x02, ua2hex(b64Url2ua(jwk.dq))],
+                [0x02, ua2hex(b64Url2ua(jwk.qi))],
+              ],
+            ],
+          ],
+        ],
+      ],
+    ])
+  }
+
+  jwk2spki(jwk: any): string {
+    return pack([
+      0x30,
+      [
+        [0x30, [[0x06, '2a864886f70d010101'], [0x05]]],
+        [
+          0x03,
+          [
+            [
+              0x30,
+              [
+                [0x02, ua2hex(b64Url2ua(jwk.n))],
+                [0x02, ua2hex(b64Url2ua(jwk.e))],
+              ],
+            ],
+          ],
+        ],
+      ],
+    ])
+  }
+
+  spkiToJwk(buf: Uint8Array): { kty: string; alg: string; n: string; e: string; ext: boolean } {
+    const asn1 = parseAsn1(new Uint8Array(buf))
+
+    var modulus: Uint8Array | undefined = undefined
+    var exponent: Uint8Array | undefined = undefined
+    if (
+      asn1.type === 0x30 &&
+      asn1.children?.[0]?.type === 0x30 &&
+      asn1.children?.[0]?.children?.[0]?.type === 0x06 &&
+      ua2hex(asn1.children?.[0]?.children?.[0]?.value ?? new Uint8Array()) === '2a864886f70d010101'
+    ) {
+      modulus = asn1.children?.[1]?.children?.[0]?.children?.[0]?.value
+      exponent = asn1.children?.[1]?.children?.[0]?.children?.[1]?.value
+    } else if (asn1.type === 0x30 && asn1.children?.[0]?.type === 0x02 && asn1.children?.[1]?.type === 0x02) {
+      modulus = asn1.children?.[0]?.value
+      exponent = asn1.children?.[1]?.value
+    }
+
+    if (!modulus || !exponent) {
+      throw new Error('Invalid spki format')
+    }
+    return {
+      kty: 'RSA',
+      alg: 'RSA-OAEP',
+      ext: true,
+      n: ua2b64Url(this.minimalRep(modulus)),
+      e: ua2b64Url(this.minimalRep(exponent)),
+    }
+  }
+
+  pkcs8ToJwk(buf: Uint8Array | ArrayBuffer) {
+    const parsed = parseAsn1(new Uint8Array(buf))
+    const seq =
+      parsed.children?.length === 3 && parsed.children[2].type === 0x04 && parsed.children[2].children?.length === 1
+        ? parsed.children[2].children[0]
+        : parsed
+    return {
+      kty: 'RSA',
+      n: ua2b64Url(this.minimalRep(seq.children![1].value as Uint8Array)),
+      e: ua2b64Url(this.minimalRep(seq.children![2].value as Uint8Array)),
+      d: ua2b64Url(this.minimalRep(seq.children![3].value as Uint8Array)),
+      p: ua2b64Url(this.minimalRep(seq.children![4].value as Uint8Array)),
+      q: ua2b64Url(this.minimalRep(seq.children![5].value as Uint8Array)),
+      dp: ua2b64Url(this.minimalRep(seq.children![6].value as Uint8Array)),
+      dq: ua2b64Url(this.minimalRep(seq.children![7].value as Uint8Array)),
+      qi: ua2b64Url(this.minimalRep(seq.children![8].value as Uint8Array)),
+    }
+  }
+
+  minimalRep(b: Uint8Array) {
+    let i = 0
+    while (b[i] === 0) {
+      i++
+    }
+    return b.slice(i)
+  }
+
+  /**
+   * Provide a view over the given Uint8Array where any trailing null bytes at
+   * the end are truncated.
+   *
+   * This can be used to ignore null bytes at the end of a padded UTF-8 string
+   * without needing to copy that string, assuming code point U+0000 is encoded
+   * in one null byte according to standards rather than in a multi-byte
+   * overlong form.
+   */
+  truncateTrailingNulls(a: Uint8Array) {
+    let end = a.byteLength - 1
+    while (a[end] === 0 && end >= 0) {
+      end--
+    }
+    // end is now either the last non-null position in a or -1; in the latter
+    // case the returned array will have length 0.
+    return a.subarray(0, end + 1)
+  }
+
+  /**
+   *
+   * @param buffer1 {Uint8Array}
+   * @param buffer2{ Uint8Array}
+   * @returns {ArrayBuffer}
+   */
+  appendBuffer(buffer1: ArrayBuffer, buffer2: ArrayBuffer): ArrayBuffer {
+    const tmp = new Uint8Array(buffer1.byteLength + buffer2.byteLength)
+    tmp.set(new Uint8Array(buffer1), 0)
+    tmp.set(new Uint8Array(buffer2), buffer1.byteLength)
+    return tmp.buffer as ArrayBuffer
+  }
+
+  //Convenience methods for dates management
+  after(d1: number, d2: number): boolean {
+    return d1 === null || d2 === null || d1 === undefined || d2 === undefined || this.moment(d1)!.isAfter(this.moment(d2)!)
+  }
+
+  before(d1: number, d2: number): boolean {
+    return d1 === null || d2 === null || d1 === undefined || d2 === undefined || this.moment(d1)!.isBefore(this.moment(d2)!)
+  }
+
+  moment(epochOrLongCalendar: number): Moment | null {
+    if (!epochOrLongCalendar && epochOrLongCalendar !== 0) {
+      return null
+    }
+    if (epochOrLongCalendar >= 18000101 && epochOrLongCalendar < 25400000) {
+      return moment('' + epochOrLongCalendar, 'YYYYMMDD')
+    } else if (epochOrLongCalendar >= 18000101000000) {
+      return moment('' + epochOrLongCalendar, 'YYYYMMDDHHmmss')
+    } else {
+      return moment(epochOrLongCalendar)
+    }
+  }
+
+  /**
+   * Encrypt object graph recursively
+   *
+   * @param obj the object to encrypt
+   * @param cryptor the cryptor function (returns a promise)
+   * @param keys the keys to be crypted: ex for a Patient ['note', 'addresses.*.["street", "houseNumber", "telecoms.*.telecomNumber"]']
+   */
+  async crypt(obj: any, cryptor: (obj: { [key: string]: string }) => Promise<ArrayBuffer>, keys: Array<string>) {
+    const subObj = _.pick(
+      obj,
+      keys.filter((k) => !k.includes('*'))
+    )
+    obj.encryptedSelf = b2a(ua2string(await cryptor(subObj)))
+    Object.keys(subObj).forEach((k) => delete obj[k])
+
+    await keys
+      .filter((k) => k.includes('*'))
+      .reduce(async (prev: Promise<void>, k: any) => {
+        await prev
+        const k1 = k.split('.*.')[0]
+        const k2 = k.substr(k1.length + 3)
+
+        const mapped = await Promise.all((_.get(obj, k1) || []).map((so: any) => this.crypt(so, cryptor, k2.startsWith('[') ? JSON.parse(k2) : [k2])))
+        _.set(obj, k1, mapped)
+      }, Promise.resolve())
+
+    return obj
+  }
+
+  /**
+   * Decrypt object graph recursively
+   *
+   * @param obj the object to encrypt
+   * @param decryptor the decryptor function (returns a promise)
+   */
+  async decrypt(obj: any, decryptor: (obj: Uint8Array) => Promise<{ [key: string]: string }>) {
+    await Object.keys(obj).reduce(async (prev: Promise<void>, k: any) => {
+      await prev
+      if (Array.isArray(obj[k])) {
+        await (obj[k] as Array<any>)
+          .filter((o) => typeof o === 'object' && o !== null)
+          .reduce(async (prev: Promise<void>, so: any) => {
+            await prev
+            await this.decrypt(so, decryptor)
+          }, Promise.resolve())
+      }
+    }, Promise.resolve())
+    if (obj.encryptedSelf) {
+      Object.assign(obj, await decryptor(string2ua(a2b(obj.encryptedSelf))))
+    }
+    return obj
+  }
+}
+
+export const utils = new UtilsClass()

package/icc-x-api/filters/AllCodesFilter.ts

@@ -0,0 +1,22 @@
+/**
+ * iCure Data Stack API Documentation
+ * The iCure Data Stack Application API is the native interface to iCure. This version is obsolete, please use v2.
+ *
+ * OpenAPI spec version: v1
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+import { AbstractFilterCode } from '../../icc-api/model/AbstractFilterCode'
+
+export class AllCodesFilter extends AbstractFilterCode {
+  $type: string = 'AllCodesFilter'
+  constructor(json: JSON | any) {
+    super(json)
+    Object.assign(this as AllCodesFilter, json)
+  }
+
+  desc?: string
+}

package/icc-x-api/filters/AllDevicesFilter.ts

@@ -0,0 +1,23 @@
+/**
+ * iCure Data Stack API Documentation
+ * The iCure Data Stack Application API is the native interface to iCure. This version is obsolete, please use v2.
+ *
+ * OpenAPI spec version: v1
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+import { AbstractFilterDevice } from '../../icc-api/model/AbstractFilterDevice'
+
+export class AllDevicesFilter extends AbstractFilterDevice {
+  $type: string = 'AllDevicesFilter'
+  constructor(json: JSON | any) {
+    super(json)
+
+    Object.assign(this as AllDevicesFilter, json)
+  }
+
+  desc?: string
+}

package/icc-x-api/filters/AllHealthcarePartiesFilter.ts

@@ -0,0 +1,23 @@
+/**
+ * iCure Data Stack API Documentation
+ * The iCure Data Stack Application API is the native interface to iCure. This version is obsolete, please use v2.
+ *
+ * OpenAPI spec version: v1
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+import { AbstractFilterHealthcareParty } from '../../icc-api/model/AbstractFilterHealthcareParty'
+
+export class AllHealthcarePartiesFilter extends AbstractFilterHealthcareParty {
+  $type: string = 'AllHealthcarePartiesFilter'
+  constructor(json: JSON | any) {
+    super(json)
+
+    Object.assign(this as AllHealthcarePartiesFilter, json)
+  }
+
+  desc?: string
+}

package/icc-x-api/filters/AllUsersFilter.ts

@@ -0,0 +1,23 @@
+/**
+ * iCure Data Stack API Documentation
+ * The iCure Data Stack Application API is the native interface to iCure. This version is obsolete, please use v2.
+ *
+ * OpenAPI spec version: v1
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+import { AbstractFilterUser } from '../../icc-api/model/AbstractFilterUser'
+
+export class AllUsersFilter extends AbstractFilterUser {
+  $type: string = 'AllUsersFilter'
+  constructor(json: JSON | any) {
+    super(json)
+
+    Object.assign(this as AllUsersFilter, json)
+  }
+
+  desc?: string
+}

package/icc-x-api/filters/CodeByIdsFilter.ts

@@ -0,0 +1,25 @@
+/**
+ * iCure Data Stack API Documentation
+ * The iCure Data Stack Application API is the native interface to iCure. This version is obsolete, please use v2.
+ *
+ * OpenAPI spec version: v1
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+
+import { AbstractFilterCode } from '../../icc-api/model/AbstractFilterCode'
+
+export class CodeByIdsFilter extends AbstractFilterCode {
+  $type: string = 'CodeByIdsFilter'
+  constructor(json: JSON | any) {
+    super(json)
+
+    Object.assign(this as CodeByIdsFilter, json)
+  }
+
+  ids?: Array<string>
+  desc?: string
+}