// Generated by ReScript, PLEASE EDIT WITH CARE

import * as SS from "../SS.bs.js";
import * as Curry from "rescript/lib/es6/curry.js";
import * as Decco from "decco/src/Decco.bs.js";
import * as Belt_Id from "rescript/lib/es6/belt_Id.js";
import * as Js_dict from "rescript/lib/es6/js_dict.js";
import * as Js_json from "rescript/lib/es6/js_json.js";
import * as Belt_Set from "rescript/lib/es6/belt_Set.js";
import * as Caml_obj from "rescript/lib/es6/caml_obj.js";
import * as Belt_Array from "rescript/lib/es6/belt_Array.js";
import * as Belt_Option from "rescript/lib/es6/belt_Option.js";
import * as Belt_Result from "rescript/lib/es6/belt_Result.js";
import * as Caml_option from "rescript/lib/es6/caml_option.js";
import * as Belt_MapString from "rescript/lib/es6/belt_MapString.js";
import * as S$RescriptStruct from "rescript-struct/src/S.bs.js";

function t_encode(v) {
  return Js_dict.fromArray([
              [
                "address",
                Decco.optionToJson(Decco.stringToJson, v.address)
              ],
              [
                "zip",
                Decco.optionToJson(Decco.stringToJson, v.zip)
              ],
              [
                "house_number",
                Decco.optionToJson(Decco.stringToJson, v.house_number)
              ],
              [
                "street",
                Decco.optionToJson(Decco.stringToJson, v.street)
              ],
              [
                "city",
                Decco.optionToJson(Decco.stringToJson, v.city)
              ],
              [
                "state",
                Decco.optionToJson(Decco.stringToJson, v.state)
              ]
            ]);
}

function t_decode(v) {
  var dict = Js_json.classify(v);
  if (typeof dict === "number") {
    return Decco.error(undefined, "Not an object", v);
  }
  if (dict.TAG !== /* JSONObject */2) {
    return Decco.error(undefined, "Not an object", v);
  }
  var dict$1 = dict._0;
  var address = Decco.optionFromJson(Decco.stringFromJson, Belt_Option.getWithDefault(Js_dict.get(dict$1, "address"), null));
  if (address.TAG === /* Ok */0) {
    var zip = Decco.optionFromJson(Decco.stringFromJson, Belt_Option.getWithDefault(Js_dict.get(dict$1, "zip"), null));
    if (zip.TAG === /* Ok */0) {
      var house_number = Decco.optionFromJson(Decco.stringFromJson, Belt_Option.getWithDefault(Js_dict.get(dict$1, "house_number"), null));
      if (house_number.TAG === /* Ok */0) {
        var street = Decco.optionFromJson(Decco.stringFromJson, Belt_Option.getWithDefault(Js_dict.get(dict$1, "street"), null));
        if (street.TAG === /* Ok */0) {
          var city = Decco.optionFromJson(Decco.stringFromJson, Belt_Option.getWithDefault(Js_dict.get(dict$1, "city"), null));
          if (city.TAG === /* Ok */0) {
            var state = Decco.optionFromJson(Decco.stringFromJson, Belt_Option.getWithDefault(Js_dict.get(dict$1, "state"), null));
            if (state.TAG === /* Ok */0) {
              return {
                      TAG: /* Ok */0,
                      _0: {
                        address: address._0,
                        zip: zip._0,
                        house_number: house_number._0,
                        street: street._0,
                        city: city._0,
                        state: state._0
                      }
                    };
            }
            var e = state._0;
            return {
                    TAG: /* Error */1,
                    _0: {
                      path: ".state" + e.path,
                      message: e.message,
                      value: e.value
                    }
                  };
          }
          var e$1 = city._0;
          return {
                  TAG: /* Error */1,
                  _0: {
                    path: ".city" + e$1.path,
                    message: e$1.message,
                    value: e$1.value
                  }
                };
        }
        var e$2 = street._0;
        return {
                TAG: /* Error */1,
                _0: {
                  path: ".street" + e$2.path,
                  message: e$2.message,
                  value: e$2.value
                }
              };
      }
      var e$3 = house_number._0;
      return {
              TAG: /* Error */1,
              _0: {
                path: ".house_number" + e$3.path,
                message: e$3.message,
                value: e$3.value
              }
            };
    }
    var e$4 = zip._0;
    return {
            TAG: /* Error */1,
            _0: {
              path: ".zip" + e$4.path,
              message: e$4.message,
              value: e$4.value
            }
          };
  }
  var e$5 = address._0;
  return {
          TAG: /* Error */1,
          _0: {
            path: ".address" + e$5.path,
            message: e$5.message,
            value: e$5.value
          }
        };
}

var struct = S$RescriptStruct.object(function (o) {
      return {
              address: S$RescriptStruct.field(o, "address", SS.safeNull(S$RescriptStruct.string(undefined))),
              zip: S$RescriptStruct.field(o, "zip", SS.safeNull(S$RescriptStruct.string(undefined))),
              house_number: S$RescriptStruct.field(o, "house_number", SS.safeNull(S$RescriptStruct.string(undefined))),
              street: S$RescriptStruct.field(o, "street", SS.safeNull(S$RescriptStruct.string(undefined))),
              city: S$RescriptStruct.field(o, "city", SS.safeNull(S$RescriptStruct.string(undefined))),
              state: S$RescriptStruct.field(o, "state", SS.safeNull(S$RescriptStruct.string(undefined)))
            };
    });

function fullAddress(param) {
  var rightPart = Belt_Array.keepMap([
          param.state,
          param.zip
        ], (function (x) {
            return x;
          })).join(" ");
  return Belt_Array.keepMap([
                param.address,
                param.city,
                rightPart
              ], (function (x) {
                  return x;
                })).join(", ");
}

var Address = {
  t_encode: t_encode,
  t_decode: t_decode,
  struct: struct,
  fullAddress: fullAddress
};

function MakeId($star) {
  var cmp = Caml_obj.compare;
  var Comparator = Belt_Id.MakeComparable({
        cmp: cmp
      });
  var t_encode = Decco.stringToJson;
  var t_decode = function (x) {
    return Belt_Result.map(Decco.stringFromJson(x), (function (prim) {
                  return prim;
                }));
  };
  var struct = S$RescriptStruct.transform(S$RescriptStruct.string(undefined), (function (x) {
          return x;
        }), undefined, (function (x) {
          return x;
        }), undefined);
  var empty = function (param) {
    return "";
  };
  var eq = function (a, b) {
    return a === b;
  };
  var eqOption = function (a, b) {
    return Belt_Option.mapWithDefault(b, false, (function (x) {
                  return a === x;
                }));
  };
  var eqString = function (a, b) {
    return a === b;
  };
  var eqOptionString = function (a, b) {
    return Belt_Option.mapWithDefault(b, false, (function (x) {
                  return a === x;
                }));
  };
  var empty$1 = Belt_Set.make(Comparator);
  var fromArray = function (param) {
    return Belt_Set.fromArray(param, Comparator);
  };
  var $$Set = {
    empty: empty$1,
    fromArray: fromArray
  };
  var t_encode$1 = function (encode, map) {
    return Js_dict.fromArray(Belt_Array.map(Belt_MapString.toArray(map), (function (param) {
                      return [
                              param[0],
                              Curry._1(encode, param[1])
                            ];
                    })));
  };
  var t_decode$1 = function (decode, json) {
    var result = Decco.dictFromJson(decode, json);
    if (result.TAG === /* Ok */0) {
      return {
              TAG: /* Ok */0,
              _0: Belt_MapString.fromArray(Js_dict.entries(result._0))
            };
    } else {
      return {
              TAG: /* Error */1,
              _0: result._0
            };
    }
  };
  var getWithId = function (map, id) {
    var value = Belt_MapString.get(map, id);
    if (value !== undefined) {
      return [
              id,
              Caml_option.valFromOption(value)
            ];
    }
    
  };
  var struct$1 = function (valueStruct) {
    return S$RescriptStruct.transform(S$RescriptStruct.dict(valueStruct), (function (x) {
                  return Belt_MapString.fromArray(Js_dict.entries(x));
                }), undefined, (function (x) {
                  return Js_dict.fromArray(Belt_MapString.toArray(x));
                }), undefined);
  };
  var $$Map = {
    empty: undefined,
    isEmpty: Belt_MapString.isEmpty,
    has: Belt_MapString.has,
    some: Belt_MapString.some,
    toArray: Belt_MapString.toArray,
    fromArray: Belt_MapString.fromArray,
    remove: Belt_MapString.remove,
    get: Belt_MapString.get,
    set: Belt_MapString.set,
    merge: Belt_MapString.merge,
    keep: Belt_MapString.keep,
    size: Belt_MapString.size,
    t_encode: t_encode$1,
    t_decode: t_decode$1,
    getWithId: getWithId,
    struct: struct$1
  };
  return {
          Comparator: Comparator,
          t_encode: t_encode,
          t_decode: t_decode,
          struct: struct,
          empty: empty,
          eq: eq,
          eqOption: eqOption,
          eqString: eqString,
          eqOptionString: eqOptionString,
          $$Set: $$Set,
          $$Map: $$Map
        };
}

var cmp = Caml_obj.compare;

var Comparator = Belt_Id.MakeComparable({
      cmp: cmp
    });

var t_encode$1 = Decco.stringToJson;

function t_decode$1(x) {
  return Belt_Result.map(Decco.stringFromJson(x), (function (prim) {
                return prim;
              }));
}

var struct$1 = S$RescriptStruct.transform(S$RescriptStruct.string(undefined), (function (x) {
        return x;
      }), undefined, (function (x) {
        return x;
      }), undefined);

function empty(param) {
  return "";
}

function eq(a, b) {
  return a === b;
}

function eqOption(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

function eqString(a, b) {
  return a === b;
}

function eqOptionString(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

var empty$1 = Belt_Set.make(Comparator);

function fromArray(param) {
  return Belt_Set.fromArray(param, Comparator);
}

var $$Set = {
  empty: empty$1,
  fromArray: fromArray
};

function t_encode$2(encode, map) {
  return Js_dict.fromArray(Belt_Array.map(Belt_MapString.toArray(map), (function (param) {
                    return [
                            param[0],
                            Curry._1(encode, param[1])
                          ];
                  })));
}

function t_decode$2(decode, json) {
  var result = Decco.dictFromJson(decode, json);
  if (result.TAG === /* Ok */0) {
    return {
            TAG: /* Ok */0,
            _0: Belt_MapString.fromArray(Js_dict.entries(result._0))
          };
  } else {
    return {
            TAG: /* Error */1,
            _0: result._0
          };
  }
}

function getWithId(map, id) {
  var value = Belt_MapString.get(map, id);
  if (value !== undefined) {
    return [
            id,
            Caml_option.valFromOption(value)
          ];
  }
  
}

function struct$2(valueStruct) {
  return S$RescriptStruct.transform(S$RescriptStruct.dict(valueStruct), (function (x) {
                return Belt_MapString.fromArray(Js_dict.entries(x));
              }), undefined, (function (x) {
                return Js_dict.fromArray(Belt_MapString.toArray(x));
              }), undefined);
}

var $$Map = {
  empty: undefined,
  isEmpty: Belt_MapString.isEmpty,
  has: Belt_MapString.has,
  some: Belt_MapString.some,
  toArray: Belt_MapString.toArray,
  fromArray: Belt_MapString.fromArray,
  remove: Belt_MapString.remove,
  get: Belt_MapString.get,
  set: Belt_MapString.set,
  merge: Belt_MapString.merge,
  keep: Belt_MapString.keep,
  size: Belt_MapString.size,
  t_encode: t_encode$2,
  t_decode: t_decode$2,
  getWithId: getWithId,
  struct: struct$2
};

var UserId = {
  Comparator: Comparator,
  t_encode: t_encode$1,
  t_decode: t_decode$1,
  struct: struct$1,
  empty: empty,
  eq: eq,
  eqOption: eqOption,
  eqString: eqString,
  eqOptionString: eqOptionString,
  $$Set: $$Set,
  $$Map: $$Map
};

var cmp$1 = Caml_obj.compare;

var Comparator$1 = Belt_Id.MakeComparable({
      cmp: cmp$1
    });

var t_encode$3 = Decco.stringToJson;

function t_decode$3(x) {
  return Belt_Result.map(Decco.stringFromJson(x), (function (prim) {
                return prim;
              }));
}

var struct$3 = S$RescriptStruct.transform(S$RescriptStruct.string(undefined), (function (x) {
        return x;
      }), undefined, (function (x) {
        return x;
      }), undefined);

function empty$2(param) {
  return "";
}

function eq$1(a, b) {
  return a === b;
}

function eqOption$1(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

function eqString$1(a, b) {
  return a === b;
}

function eqOptionString$1(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

var empty$3 = Belt_Set.make(Comparator$1);

function fromArray$1(param) {
  return Belt_Set.fromArray(param, Comparator$1);
}

var $$Set$1 = {
  empty: empty$3,
  fromArray: fromArray$1
};

function t_encode$4(encode, map) {
  return Js_dict.fromArray(Belt_Array.map(Belt_MapString.toArray(map), (function (param) {
                    return [
                            param[0],
                            Curry._1(encode, param[1])
                          ];
                  })));
}

function t_decode$4(decode, json) {
  var result = Decco.dictFromJson(decode, json);
  if (result.TAG === /* Ok */0) {
    return {
            TAG: /* Ok */0,
            _0: Belt_MapString.fromArray(Js_dict.entries(result._0))
          };
  } else {
    return {
            TAG: /* Error */1,
            _0: result._0
          };
  }
}

function getWithId$1(map, id) {
  var value = Belt_MapString.get(map, id);
  if (value !== undefined) {
    return [
            id,
            Caml_option.valFromOption(value)
          ];
  }
  
}

function struct$4(valueStruct) {
  return S$RescriptStruct.transform(S$RescriptStruct.dict(valueStruct), (function (x) {
                return Belt_MapString.fromArray(Js_dict.entries(x));
              }), undefined, (function (x) {
                return Js_dict.fromArray(Belt_MapString.toArray(x));
              }), undefined);
}

var $$Map$1 = {
  empty: undefined,
  isEmpty: Belt_MapString.isEmpty,
  has: Belt_MapString.has,
  some: Belt_MapString.some,
  toArray: Belt_MapString.toArray,
  fromArray: Belt_MapString.fromArray,
  remove: Belt_MapString.remove,
  get: Belt_MapString.get,
  set: Belt_MapString.set,
  merge: Belt_MapString.merge,
  keep: Belt_MapString.keep,
  size: Belt_MapString.size,
  t_encode: t_encode$4,
  t_decode: t_decode$4,
  getWithId: getWithId$1,
  struct: struct$4
};

var TeamId = {
  Comparator: Comparator$1,
  t_encode: t_encode$3,
  t_decode: t_decode$3,
  struct: struct$3,
  empty: empty$2,
  eq: eq$1,
  eqOption: eqOption$1,
  eqString: eqString$1,
  eqOptionString: eqOptionString$1,
  $$Set: $$Set$1,
  $$Map: $$Map$1
};

var cmp$2 = Caml_obj.compare;

var Comparator$2 = Belt_Id.MakeComparable({
      cmp: cmp$2
    });

var t_encode$5 = Decco.stringToJson;

function t_decode$5(x) {
  return Belt_Result.map(Decco.stringFromJson(x), (function (prim) {
                return prim;
              }));
}

var struct$5 = S$RescriptStruct.transform(S$RescriptStruct.string(undefined), (function (x) {
        return x;
      }), undefined, (function (x) {
        return x;
      }), undefined);

function empty$4(param) {
  return "";
}

function eq$2(a, b) {
  return a === b;
}

function eqOption$2(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

function eqString$2(a, b) {
  return a === b;
}

function eqOptionString$2(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

var empty$5 = Belt_Set.make(Comparator$2);

function fromArray$2(param) {
  return Belt_Set.fromArray(param, Comparator$2);
}

var $$Set$2 = {
  empty: empty$5,
  fromArray: fromArray$2
};

function t_encode$6(encode, map) {
  return Js_dict.fromArray(Belt_Array.map(Belt_MapString.toArray(map), (function (param) {
                    return [
                            param[0],
                            Curry._1(encode, param[1])
                          ];
                  })));
}

function t_decode$6(decode, json) {
  var result = Decco.dictFromJson(decode, json);
  if (result.TAG === /* Ok */0) {
    return {
            TAG: /* Ok */0,
            _0: Belt_MapString.fromArray(Js_dict.entries(result._0))
          };
  } else {
    return {
            TAG: /* Error */1,
            _0: result._0
          };
  }
}

function getWithId$2(map, id) {
  var value = Belt_MapString.get(map, id);
  if (value !== undefined) {
    return [
            id,
            Caml_option.valFromOption(value)
          ];
  }
  
}

function struct$6(valueStruct) {
  return S$RescriptStruct.transform(S$RescriptStruct.dict(valueStruct), (function (x) {
                return Belt_MapString.fromArray(Js_dict.entries(x));
              }), undefined, (function (x) {
                return Js_dict.fromArray(Belt_MapString.toArray(x));
              }), undefined);
}

var $$Map$2 = {
  empty: undefined,
  isEmpty: Belt_MapString.isEmpty,
  has: Belt_MapString.has,
  some: Belt_MapString.some,
  toArray: Belt_MapString.toArray,
  fromArray: Belt_MapString.fromArray,
  remove: Belt_MapString.remove,
  get: Belt_MapString.get,
  set: Belt_MapString.set,
  merge: Belt_MapString.merge,
  keep: Belt_MapString.keep,
  size: Belt_MapString.size,
  t_encode: t_encode$6,
  t_decode: t_decode$6,
  getWithId: getWithId$2,
  struct: struct$6
};

var SpaceId = {
  Comparator: Comparator$2,
  t_encode: t_encode$5,
  t_decode: t_decode$5,
  struct: struct$5,
  empty: empty$4,
  eq: eq$2,
  eqOption: eqOption$2,
  eqString: eqString$2,
  eqOptionString: eqOptionString$2,
  $$Set: $$Set$2,
  $$Map: $$Map$2
};

var cmp$3 = Caml_obj.compare;

var Comparator$3 = Belt_Id.MakeComparable({
      cmp: cmp$3
    });

var t_encode$7 = Decco.stringToJson;

function t_decode$7(x) {
  return Belt_Result.map(Decco.stringFromJson(x), (function (prim) {
                return prim;
              }));
}

var struct$7 = S$RescriptStruct.transform(S$RescriptStruct.string(undefined), (function (x) {
        return x;
      }), undefined, (function (x) {
        return x;
      }), undefined);

function empty$6(param) {
  return "";
}

function eq$3(a, b) {
  return a === b;
}

function eqOption$3(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

function eqString$3(a, b) {
  return a === b;
}

function eqOptionString$3(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

var empty$7 = Belt_Set.make(Comparator$3);

function fromArray$3(param) {
  return Belt_Set.fromArray(param, Comparator$3);
}

var $$Set$3 = {
  empty: empty$7,
  fromArray: fromArray$3
};

function t_encode$8(encode, map) {
  return Js_dict.fromArray(Belt_Array.map(Belt_MapString.toArray(map), (function (param) {
                    return [
                            param[0],
                            Curry._1(encode, param[1])
                          ];
                  })));
}

function t_decode$8(decode, json) {
  var result = Decco.dictFromJson(decode, json);
  if (result.TAG === /* Ok */0) {
    return {
            TAG: /* Ok */0,
            _0: Belt_MapString.fromArray(Js_dict.entries(result._0))
          };
  } else {
    return {
            TAG: /* Error */1,
            _0: result._0
          };
  }
}

function getWithId$3(map, id) {
  var value = Belt_MapString.get(map, id);
  if (value !== undefined) {
    return [
            id,
            Caml_option.valFromOption(value)
          ];
  }
  
}

function struct$8(valueStruct) {
  return S$RescriptStruct.transform(S$RescriptStruct.dict(valueStruct), (function (x) {
                return Belt_MapString.fromArray(Js_dict.entries(x));
              }), undefined, (function (x) {
                return Js_dict.fromArray(Belt_MapString.toArray(x));
              }), undefined);
}

var $$Map$3 = {
  empty: undefined,
  isEmpty: Belt_MapString.isEmpty,
  has: Belt_MapString.has,
  some: Belt_MapString.some,
  toArray: Belt_MapString.toArray,
  fromArray: Belt_MapString.fromArray,
  remove: Belt_MapString.remove,
  get: Belt_MapString.get,
  set: Belt_MapString.set,
  merge: Belt_MapString.merge,
  keep: Belt_MapString.keep,
  size: Belt_MapString.size,
  t_encode: t_encode$8,
  t_decode: t_decode$8,
  getWithId: getWithId$3,
  struct: struct$8
};

var MemberId = {
  Comparator: Comparator$3,
  t_encode: t_encode$7,
  t_decode: t_decode$7,
  struct: struct$7,
  empty: empty$6,
  eq: eq$3,
  eqOption: eqOption$3,
  eqString: eqString$3,
  eqOptionString: eqOptionString$3,
  $$Set: $$Set$3,
  $$Map: $$Map$3
};

var cmp$4 = Caml_obj.compare;

var Comparator$4 = Belt_Id.MakeComparable({
      cmp: cmp$4
    });

var t_encode$9 = Decco.stringToJson;

function t_decode$9(x) {
  return Belt_Result.map(Decco.stringFromJson(x), (function (prim) {
                return prim;
              }));
}

var struct$9 = S$RescriptStruct.transform(S$RescriptStruct.string(undefined), (function (x) {
        return x;
      }), undefined, (function (x) {
        return x;
      }), undefined);

function empty$8(param) {
  return "";
}

function eq$4(a, b) {
  return a === b;
}

function eqOption$4(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

function eqString$4(a, b) {
  return a === b;
}

function eqOptionString$4(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

var empty$9 = Belt_Set.make(Comparator$4);

function fromArray$4(param) {
  return Belt_Set.fromArray(param, Comparator$4);
}

var $$Set$4 = {
  empty: empty$9,
  fromArray: fromArray$4
};

function t_encode$10(encode, map) {
  return Js_dict.fromArray(Belt_Array.map(Belt_MapString.toArray(map), (function (param) {
                    return [
                            param[0],
                            Curry._1(encode, param[1])
                          ];
                  })));
}

function t_decode$10(decode, json) {
  var result = Decco.dictFromJson(decode, json);
  if (result.TAG === /* Ok */0) {
    return {
            TAG: /* Ok */0,
            _0: Belt_MapString.fromArray(Js_dict.entries(result._0))
          };
  } else {
    return {
            TAG: /* Error */1,
            _0: result._0
          };
  }
}

function getWithId$4(map, id) {
  var value = Belt_MapString.get(map, id);
  if (value !== undefined) {
    return [
            id,
            Caml_option.valFromOption(value)
          ];
  }
  
}

function struct$10(valueStruct) {
  return S$RescriptStruct.transform(S$RescriptStruct.dict(valueStruct), (function (x) {
                return Belt_MapString.fromArray(Js_dict.entries(x));
              }), undefined, (function (x) {
                return Js_dict.fromArray(Belt_MapString.toArray(x));
              }), undefined);
}

var $$Map$4 = {
  empty: undefined,
  isEmpty: Belt_MapString.isEmpty,
  has: Belt_MapString.has,
  some: Belt_MapString.some,
  toArray: Belt_MapString.toArray,
  fromArray: Belt_MapString.fromArray,
  remove: Belt_MapString.remove,
  get: Belt_MapString.get,
  set: Belt_MapString.set,
  merge: Belt_MapString.merge,
  keep: Belt_MapString.keep,
  size: Belt_MapString.size,
  t_encode: t_encode$10,
  t_decode: t_decode$10,
  getWithId: getWithId$4,
  struct: struct$10
};

var BoardId = {
  Comparator: Comparator$4,
  t_encode: t_encode$9,
  t_decode: t_decode$9,
  struct: struct$9,
  empty: empty$8,
  eq: eq$4,
  eqOption: eqOption$4,
  eqString: eqString$4,
  eqOptionString: eqOptionString$4,
  $$Set: $$Set$4,
  $$Map: $$Map$4
};

var cmp$5 = Caml_obj.compare;

var Comparator$5 = Belt_Id.MakeComparable({
      cmp: cmp$5
    });

var t_encode$11 = Decco.stringToJson;

function t_decode$11(x) {
  return Belt_Result.map(Decco.stringFromJson(x), (function (prim) {
                return prim;
              }));
}

var struct$11 = S$RescriptStruct.transform(S$RescriptStruct.string(undefined), (function (x) {
        return x;
      }), undefined, (function (x) {
        return x;
      }), undefined);

function empty$10(param) {
  return "";
}

function eq$5(a, b) {
  return a === b;
}

function eqOption$5(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

function eqString$5(a, b) {
  return a === b;
}

function eqOptionString$5(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

var empty$11 = Belt_Set.make(Comparator$5);

function fromArray$5(param) {
  return Belt_Set.fromArray(param, Comparator$5);
}

var $$Set$5 = {
  empty: empty$11,
  fromArray: fromArray$5
};

function t_encode$12(encode, map) {
  return Js_dict.fromArray(Belt_Array.map(Belt_MapString.toArray(map), (function (param) {
                    return [
                            param[0],
                            Curry._1(encode, param[1])
                          ];
                  })));
}

function t_decode$12(decode, json) {
  var result = Decco.dictFromJson(decode, json);
  if (result.TAG === /* Ok */0) {
    return {
            TAG: /* Ok */0,
            _0: Belt_MapString.fromArray(Js_dict.entries(result._0))
          };
  } else {
    return {
            TAG: /* Error */1,
            _0: result._0
          };
  }
}

function getWithId$5(map, id) {
  var value = Belt_MapString.get(map, id);
  if (value !== undefined) {
    return [
            id,
            Caml_option.valFromOption(value)
          ];
  }
  
}

function struct$12(valueStruct) {
  return S$RescriptStruct.transform(S$RescriptStruct.dict(valueStruct), (function (x) {
                return Belt_MapString.fromArray(Js_dict.entries(x));
              }), undefined, (function (x) {
                return Js_dict.fromArray(Belt_MapString.toArray(x));
              }), undefined);
}

var $$Map$5 = {
  empty: undefined,
  isEmpty: Belt_MapString.isEmpty,
  has: Belt_MapString.has,
  some: Belt_MapString.some,
  toArray: Belt_MapString.toArray,
  fromArray: Belt_MapString.fromArray,
  remove: Belt_MapString.remove,
  get: Belt_MapString.get,
  set: Belt_MapString.set,
  merge: Belt_MapString.merge,
  keep: Belt_MapString.keep,
  size: Belt_MapString.size,
  t_encode: t_encode$12,
  t_decode: t_decode$12,
  getWithId: getWithId$5,
  struct: struct$12
};

var BlockId = {
  Comparator: Comparator$5,
  t_encode: t_encode$11,
  t_decode: t_decode$11,
  struct: struct$11,
  empty: empty$10,
  eq: eq$5,
  eqOption: eqOption$5,
  eqString: eqString$5,
  eqOptionString: eqOptionString$5,
  $$Set: $$Set$5,
  $$Map: $$Map$5
};

var cmp$6 = Caml_obj.compare;

var Comparator$6 = Belt_Id.MakeComparable({
      cmp: cmp$6
    });

var t_encode$13 = Decco.stringToJson;

function t_decode$13(x) {
  return Belt_Result.map(Decco.stringFromJson(x), (function (prim) {
                return prim;
              }));
}

var struct$13 = S$RescriptStruct.transform(S$RescriptStruct.string(undefined), (function (x) {
        return x;
      }), undefined, (function (x) {
        return x;
      }), undefined);

function empty$12(param) {
  return "";
}

function eq$6(a, b) {
  return a === b;
}

function eqOption$6(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

function eqString$6(a, b) {
  return a === b;
}

function eqOptionString$6(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

var empty$13 = Belt_Set.make(Comparator$6);

function fromArray$6(param) {
  return Belt_Set.fromArray(param, Comparator$6);
}

var $$Set$6 = {
  empty: empty$13,
  fromArray: fromArray$6
};

function t_encode$14(encode, map) {
  return Js_dict.fromArray(Belt_Array.map(Belt_MapString.toArray(map), (function (param) {
                    return [
                            param[0],
                            Curry._1(encode, param[1])
                          ];
                  })));
}

function t_decode$14(decode, json) {
  var result = Decco.dictFromJson(decode, json);
  if (result.TAG === /* Ok */0) {
    return {
            TAG: /* Ok */0,
            _0: Belt_MapString.fromArray(Js_dict.entries(result._0))
          };
  } else {
    return {
            TAG: /* Error */1,
            _0: result._0
          };
  }
}

function getWithId$6(map, id) {
  var value = Belt_MapString.get(map, id);
  if (value !== undefined) {
    return [
            id,
            Caml_option.valFromOption(value)
          ];
  }
  
}

function struct$14(valueStruct) {
  return S$RescriptStruct.transform(S$RescriptStruct.dict(valueStruct), (function (x) {
                return Belt_MapString.fromArray(Js_dict.entries(x));
              }), undefined, (function (x) {
                return Js_dict.fromArray(Belt_MapString.toArray(x));
              }), undefined);
}

var $$Map$6 = {
  empty: undefined,
  isEmpty: Belt_MapString.isEmpty,
  has: Belt_MapString.has,
  some: Belt_MapString.some,
  toArray: Belt_MapString.toArray,
  fromArray: Belt_MapString.fromArray,
  remove: Belt_MapString.remove,
  get: Belt_MapString.get,
  set: Belt_MapString.set,
  merge: Belt_MapString.merge,
  keep: Belt_MapString.keep,
  size: Belt_MapString.size,
  t_encode: t_encode$14,
  t_decode: t_decode$14,
  getWithId: getWithId$6,
  struct: struct$14
};

var PartnerId = {
  Comparator: Comparator$6,
  t_encode: t_encode$13,
  t_decode: t_decode$13,
  struct: struct$13,
  empty: empty$12,
  eq: eq$6,
  eqOption: eqOption$6,
  eqString: eqString$6,
  eqOptionString: eqOptionString$6,
  $$Set: $$Set$6,
  $$Map: $$Map$6
};

var cmp$7 = Caml_obj.compare;

var Comparator$7 = Belt_Id.MakeComparable({
      cmp: cmp$7
    });

var t_encode$15 = Decco.stringToJson;

function t_decode$15(x) {
  return Belt_Result.map(Decco.stringFromJson(x), (function (prim) {
                return prim;
              }));
}

var struct$15 = S$RescriptStruct.transform(S$RescriptStruct.string(undefined), (function (x) {
        return x;
      }), undefined, (function (x) {
        return x;
      }), undefined);

function empty$14(param) {
  return "";
}

function eq$7(a, b) {
  return a === b;
}

function eqOption$7(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

function eqString$7(a, b) {
  return a === b;
}

function eqOptionString$7(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

var empty$15 = Belt_Set.make(Comparator$7);

function fromArray$7(param) {
  return Belt_Set.fromArray(param, Comparator$7);
}

var $$Set$7 = {
  empty: empty$15,
  fromArray: fromArray$7
};

function t_encode$16(encode, map) {
  return Js_dict.fromArray(Belt_Array.map(Belt_MapString.toArray(map), (function (param) {
                    return [
                            param[0],
                            Curry._1(encode, param[1])
                          ];
                  })));
}

function t_decode$16(decode, json) {
  var result = Decco.dictFromJson(decode, json);
  if (result.TAG === /* Ok */0) {
    return {
            TAG: /* Ok */0,
            _0: Belt_MapString.fromArray(Js_dict.entries(result._0))
          };
  } else {
    return {
            TAG: /* Error */1,
            _0: result._0
          };
  }
}

function getWithId$7(map, id) {
  var value = Belt_MapString.get(map, id);
  if (value !== undefined) {
    return [
            id,
            Caml_option.valFromOption(value)
          ];
  }
  
}

function struct$16(valueStruct) {
  return S$RescriptStruct.transform(S$RescriptStruct.dict(valueStruct), (function (x) {
                return Belt_MapString.fromArray(Js_dict.entries(x));
              }), undefined, (function (x) {
                return Js_dict.fromArray(Belt_MapString.toArray(x));
              }), undefined);
}

var $$Map$7 = {
  empty: undefined,
  isEmpty: Belt_MapString.isEmpty,
  has: Belt_MapString.has,
  some: Belt_MapString.some,
  toArray: Belt_MapString.toArray,
  fromArray: Belt_MapString.fromArray,
  remove: Belt_MapString.remove,
  get: Belt_MapString.get,
  set: Belt_MapString.set,
  merge: Belt_MapString.merge,
  keep: Belt_MapString.keep,
  size: Belt_MapString.size,
  t_encode: t_encode$16,
  t_decode: t_decode$16,
  getWithId: getWithId$7,
  struct: struct$16
};

var StatusId = {
  Comparator: Comparator$7,
  t_encode: t_encode$15,
  t_decode: t_decode$15,
  struct: struct$15,
  empty: empty$14,
  eq: eq$7,
  eqOption: eqOption$7,
  eqString: eqString$7,
  eqOptionString: eqOptionString$7,
  $$Set: $$Set$7,
  $$Map: $$Map$7
};

var cmp$8 = Caml_obj.compare;

var Comparator$8 = Belt_Id.MakeComparable({
      cmp: cmp$8
    });

var t_encode$17 = Decco.stringToJson;

function t_decode$17(x) {
  return Belt_Result.map(Decco.stringFromJson(x), (function (prim) {
                return prim;
              }));
}

var struct$17 = S$RescriptStruct.transform(S$RescriptStruct.string(undefined), (function (x) {
        return x;
      }), undefined, (function (x) {
        return x;
      }), undefined);

function empty$16(param) {
  return "";
}

function eq$8(a, b) {
  return a === b;
}

function eqOption$8(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

function eqString$8(a, b) {
  return a === b;
}

function eqOptionString$8(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

var empty$17 = Belt_Set.make(Comparator$8);

function fromArray$8(param) {
  return Belt_Set.fromArray(param, Comparator$8);
}

var $$Set$8 = {
  empty: empty$17,
  fromArray: fromArray$8
};

function t_encode$18(encode, map) {
  return Js_dict.fromArray(Belt_Array.map(Belt_MapString.toArray(map), (function (param) {
                    return [
                            param[0],
                            Curry._1(encode, param[1])
                          ];
                  })));
}

function t_decode$18(decode, json) {
  var result = Decco.dictFromJson(decode, json);
  if (result.TAG === /* Ok */0) {
    return {
            TAG: /* Ok */0,
            _0: Belt_MapString.fromArray(Js_dict.entries(result._0))
          };
  } else {
    return {
            TAG: /* Error */1,
            _0: result._0
          };
  }
}

function getWithId$8(map, id) {
  var value = Belt_MapString.get(map, id);
  if (value !== undefined) {
    return [
            id,
            Caml_option.valFromOption(value)
          ];
  }
  
}

function struct$18(valueStruct) {
  return S$RescriptStruct.transform(S$RescriptStruct.dict(valueStruct), (function (x) {
                return Belt_MapString.fromArray(Js_dict.entries(x));
              }), undefined, (function (x) {
                return Js_dict.fromArray(Belt_MapString.toArray(x));
              }), undefined);
}

var $$Map$8 = {
  empty: undefined,
  isEmpty: Belt_MapString.isEmpty,
  has: Belt_MapString.has,
  some: Belt_MapString.some,
  toArray: Belt_MapString.toArray,
  fromArray: Belt_MapString.fromArray,
  remove: Belt_MapString.remove,
  get: Belt_MapString.get,
  set: Belt_MapString.set,
  merge: Belt_MapString.merge,
  keep: Belt_MapString.keep,
  size: Belt_MapString.size,
  t_encode: t_encode$18,
  t_decode: t_decode$18,
  getWithId: getWithId$8,
  struct: struct$18
};

var OptionId = {
  Comparator: Comparator$8,
  t_encode: t_encode$17,
  t_decode: t_decode$17,
  struct: struct$17,
  empty: empty$16,
  eq: eq$8,
  eqOption: eqOption$8,
  eqString: eqString$8,
  eqOptionString: eqOptionString$8,
  $$Set: $$Set$8,
  $$Map: $$Map$8
};

var cmp$9 = Caml_obj.compare;

var Comparator$9 = Belt_Id.MakeComparable({
      cmp: cmp$9
    });

var t_encode$19 = Decco.stringToJson;

function t_decode$19(x) {
  return Belt_Result.map(Decco.stringFromJson(x), (function (prim) {
                return prim;
              }));
}

var struct$19 = S$RescriptStruct.transform(S$RescriptStruct.string(undefined), (function (x) {
        return x;
      }), undefined, (function (x) {
        return x;
      }), undefined);

function empty$18(param) {
  return "";
}

function eq$9(a, b) {
  return a === b;
}

function eqOption$9(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

function eqString$9(a, b) {
  return a === b;
}

function eqOptionString$9(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

var empty$19 = Belt_Set.make(Comparator$9);

function fromArray$9(param) {
  return Belt_Set.fromArray(param, Comparator$9);
}

var $$Set$9 = {
  empty: empty$19,
  fromArray: fromArray$9
};

function t_encode$20(encode, map) {
  return Js_dict.fromArray(Belt_Array.map(Belt_MapString.toArray(map), (function (param) {
                    return [
                            param[0],
                            Curry._1(encode, param[1])
                          ];
                  })));
}

function t_decode$20(decode, json) {
  var result = Decco.dictFromJson(decode, json);
  if (result.TAG === /* Ok */0) {
    return {
            TAG: /* Ok */0,
            _0: Belt_MapString.fromArray(Js_dict.entries(result._0))
          };
  } else {
    return {
            TAG: /* Error */1,
            _0: result._0
          };
  }
}

function getWithId$9(map, id) {
  var value = Belt_MapString.get(map, id);
  if (value !== undefined) {
    return [
            id,
            Caml_option.valFromOption(value)
          ];
  }
  
}

function struct$20(valueStruct) {
  return S$RescriptStruct.transform(S$RescriptStruct.dict(valueStruct), (function (x) {
                return Belt_MapString.fromArray(Js_dict.entries(x));
              }), undefined, (function (x) {
                return Js_dict.fromArray(Belt_MapString.toArray(x));
              }), undefined);
}

var $$Map$9 = {
  empty: undefined,
  isEmpty: Belt_MapString.isEmpty,
  has: Belt_MapString.has,
  some: Belt_MapString.some,
  toArray: Belt_MapString.toArray,
  fromArray: Belt_MapString.fromArray,
  remove: Belt_MapString.remove,
  get: Belt_MapString.get,
  set: Belt_MapString.set,
  merge: Belt_MapString.merge,
  keep: Belt_MapString.keep,
  size: Belt_MapString.size,
  t_encode: t_encode$20,
  t_decode: t_decode$20,
  getWithId: getWithId$9,
  struct: struct$20
};

var ContactId = {
  Comparator: Comparator$9,
  t_encode: t_encode$19,
  t_decode: t_decode$19,
  struct: struct$19,
  empty: empty$18,
  eq: eq$9,
  eqOption: eqOption$9,
  eqString: eqString$9,
  eqOptionString: eqOptionString$9,
  $$Set: $$Set$9,
  $$Map: $$Map$9
};

var cmp$10 = Caml_obj.compare;

var Comparator$10 = Belt_Id.MakeComparable({
      cmp: cmp$10
    });

var t_encode$21 = Decco.stringToJson;

function t_decode$21(x) {
  return Belt_Result.map(Decco.stringFromJson(x), (function (prim) {
                return prim;
              }));
}

var struct$21 = S$RescriptStruct.transform(S$RescriptStruct.string(undefined), (function (x) {
        return x;
      }), undefined, (function (x) {
        return x;
      }), undefined);

function empty$20(param) {
  return "";
}

function eq$10(a, b) {
  return a === b;
}

function eqOption$10(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

function eqString$10(a, b) {
  return a === b;
}

function eqOptionString$10(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

var empty$21 = Belt_Set.make(Comparator$10);

function fromArray$10(param) {
  return Belt_Set.fromArray(param, Comparator$10);
}

var $$Set$10 = {
  empty: empty$21,
  fromArray: fromArray$10
};

function t_encode$22(encode, map) {
  return Js_dict.fromArray(Belt_Array.map(Belt_MapString.toArray(map), (function (param) {
                    return [
                            param[0],
                            Curry._1(encode, param[1])
                          ];
                  })));
}

function t_decode$22(decode, json) {
  var result = Decco.dictFromJson(decode, json);
  if (result.TAG === /* Ok */0) {
    return {
            TAG: /* Ok */0,
            _0: Belt_MapString.fromArray(Js_dict.entries(result._0))
          };
  } else {
    return {
            TAG: /* Error */1,
            _0: result._0
          };
  }
}

function getWithId$10(map, id) {
  var value = Belt_MapString.get(map, id);
  if (value !== undefined) {
    return [
            id,
            Caml_option.valFromOption(value)
          ];
  }
  
}

function struct$22(valueStruct) {
  return S$RescriptStruct.transform(S$RescriptStruct.dict(valueStruct), (function (x) {
                return Belt_MapString.fromArray(Js_dict.entries(x));
              }), undefined, (function (x) {
                return Js_dict.fromArray(Belt_MapString.toArray(x));
              }), undefined);
}

var $$Map$10 = {
  empty: undefined,
  isEmpty: Belt_MapString.isEmpty,
  has: Belt_MapString.has,
  some: Belt_MapString.some,
  toArray: Belt_MapString.toArray,
  fromArray: Belt_MapString.fromArray,
  remove: Belt_MapString.remove,
  get: Belt_MapString.get,
  set: Belt_MapString.set,
  merge: Belt_MapString.merge,
  keep: Belt_MapString.keep,
  size: Belt_MapString.size,
  t_encode: t_encode$22,
  t_decode: t_decode$22,
  getWithId: getWithId$10,
  struct: struct$22
};

var ContactFieldId = {
  Comparator: Comparator$10,
  t_encode: t_encode$21,
  t_decode: t_decode$21,
  struct: struct$21,
  empty: empty$20,
  eq: eq$10,
  eqOption: eqOption$10,
  eqString: eqString$10,
  eqOptionString: eqOptionString$10,
  $$Set: $$Set$10,
  $$Map: $$Map$10
};

var cmp$11 = Caml_obj.compare;

var Comparator$11 = Belt_Id.MakeComparable({
      cmp: cmp$11
    });

var t_encode$23 = Decco.stringToJson;

function t_decode$23(x) {
  return Belt_Result.map(Decco.stringFromJson(x), (function (prim) {
                return prim;
              }));
}

var struct$23 = S$RescriptStruct.transform(S$RescriptStruct.string(undefined), (function (x) {
        return x;
      }), undefined, (function (x) {
        return x;
      }), undefined);

function empty$22(param) {
  return "";
}

function eq$11(a, b) {
  return a === b;
}

function eqOption$11(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

function eqString$11(a, b) {
  return a === b;
}

function eqOptionString$11(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

var empty$23 = Belt_Set.make(Comparator$11);

function fromArray$11(param) {
  return Belt_Set.fromArray(param, Comparator$11);
}

var $$Set$11 = {
  empty: empty$23,
  fromArray: fromArray$11
};

function t_encode$24(encode, map) {
  return Js_dict.fromArray(Belt_Array.map(Belt_MapString.toArray(map), (function (param) {
                    return [
                            param[0],
                            Curry._1(encode, param[1])
                          ];
                  })));
}

function t_decode$24(decode, json) {
  var result = Decco.dictFromJson(decode, json);
  if (result.TAG === /* Ok */0) {
    return {
            TAG: /* Ok */0,
            _0: Belt_MapString.fromArray(Js_dict.entries(result._0))
          };
  } else {
    return {
            TAG: /* Error */1,
            _0: result._0
          };
  }
}

function getWithId$11(map, id) {
  var value = Belt_MapString.get(map, id);
  if (value !== undefined) {
    return [
            id,
            Caml_option.valFromOption(value)
          ];
  }
  
}

function struct$24(valueStruct) {
  return S$RescriptStruct.transform(S$RescriptStruct.dict(valueStruct), (function (x) {
                return Belt_MapString.fromArray(Js_dict.entries(x));
              }), undefined, (function (x) {
                return Js_dict.fromArray(Belt_MapString.toArray(x));
              }), undefined);
}

var $$Map$11 = {
  empty: undefined,
  isEmpty: Belt_MapString.isEmpty,
  has: Belt_MapString.has,
  some: Belt_MapString.some,
  toArray: Belt_MapString.toArray,
  fromArray: Belt_MapString.fromArray,
  remove: Belt_MapString.remove,
  get: Belt_MapString.get,
  set: Belt_MapString.set,
  merge: Belt_MapString.merge,
  keep: Belt_MapString.keep,
  size: Belt_MapString.size,
  t_encode: t_encode$24,
  t_decode: t_decode$24,
  getWithId: getWithId$11,
  struct: struct$24
};

var ImportId = {
  Comparator: Comparator$11,
  t_encode: t_encode$23,
  t_decode: t_decode$23,
  struct: struct$23,
  empty: empty$22,
  eq: eq$11,
  eqOption: eqOption$11,
  eqString: eqString$11,
  eqOptionString: eqOptionString$11,
  $$Set: $$Set$11,
  $$Map: $$Map$11
};

var cmp$12 = Caml_obj.compare;

var Comparator$12 = Belt_Id.MakeComparable({
      cmp: cmp$12
    });

var t_encode$25 = Decco.stringToJson;

function t_decode$25(x) {
  return Belt_Result.map(Decco.stringFromJson(x), (function (prim) {
                return prim;
              }));
}

var struct$25 = S$RescriptStruct.transform(S$RescriptStruct.string(undefined), (function (x) {
        return x;
      }), undefined, (function (x) {
        return x;
      }), undefined);

function empty$24(param) {
  return "";
}

function eq$12(a, b) {
  return a === b;
}

function eqOption$12(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

function eqString$12(a, b) {
  return a === b;
}

function eqOptionString$12(a, b) {
  return Belt_Option.mapWithDefault(b, false, (function (x) {
                return a === x;
              }));
}

var empty$25 = Belt_Set.make(Comparator$12);

function fromArray$12(param) {
  return Belt_Set.fromArray(param, Comparator$12);
}

var $$Set$12 = {
  empty: empty$25,
  fromArray: fromArray$12
};

function t_encode$26(encode, map) {
  return Js_dict.fromArray(Belt_Array.map(Belt_MapString.toArray(map), (function (param) {
                    return [
                            param[0],
                            Curry._1(encode, param[1])
                          ];
                  })));
}

function t_decode$26(decode, json) {
  var result = Decco.dictFromJson(decode, json);
  if (result.TAG === /* Ok */0) {
    return {
            TAG: /* Ok */0,
            _0: Belt_MapString.fromArray(Js_dict.entries(result._0))
          };
  } else {
    return {
            TAG: /* Error */1,
            _0: result._0
          };
  }
}

function getWithId$12(map, id) {
  var value = Belt_MapString.get(map, id);
  if (value !== undefined) {
    return [
            id,
            Caml_option.valFromOption(value)
          ];
  }
  
}

function struct$26(valueStruct) {
  return S$RescriptStruct.transform(S$RescriptStruct.dict(valueStruct), (function (x) {
                return Belt_MapString.fromArray(Js_dict.entries(x));
              }), undefined, (function (x) {
                return Js_dict.fromArray(Belt_MapString.toArray(x));
              }), undefined);
}

var $$Map$12 = {
  empty: undefined,
  isEmpty: Belt_MapString.isEmpty,
  has: Belt_MapString.has,
  some: Belt_MapString.some,
  toArray: Belt_MapString.toArray,
  fromArray: Belt_MapString.fromArray,
  remove: Belt_MapString.remove,
  get: Belt_MapString.get,
  set: Belt_MapString.set,
  merge: Belt_MapString.merge,
  keep: Belt_MapString.keep,
  size: Belt_MapString.size,
  t_encode: t_encode$26,
  t_decode: t_decode$26,
  getWithId: getWithId$12,
  struct: struct$26
};

var StoredPropertyId = {
  Comparator: Comparator$12,
  t_encode: t_encode$25,
  t_decode: t_decode$25,
  struct: struct$25,
  empty: empty$24,
  eq: eq$12,
  eqOption: eqOption$12,
  eqString: eqString$12,
  eqOptionString: eqOptionString$12,
  $$Set: $$Set$12,
  $$Map: $$Map$12
};

export {
  Address ,
  MakeId ,
  UserId ,
  TeamId ,
  SpaceId ,
  MemberId ,
  BoardId ,
  BlockId ,
  PartnerId ,
  StatusId ,
  OptionId ,
  ContactId ,
  ContactFieldId ,
  ImportId ,
  StoredPropertyId ,
}
/* struct Not a pure module */
