@jsm-mit/map-routes-package 0.0.0-stage → 0.2.0

package/declarations/map-routes-coordinator/map-routes-coordinator.did.js

@@ -0,0 +1,303 @@
+export const idlFactory = ({ IDL }) => {
+  const Mode = IDL.Variant({
+    'Local' : IDL.Null,
+    'Stage' : IDL.Null,
+    'Prod' : IDL.Null,
+  });
+  const InitArgs = IDL.Record({
+    'mode' : Mode,
+    'superadmins' : IDL.Vec(IDL.Principal),
+  });
+  const Bbox = IDL.Record({
+    'minLat' : IDL.Float64,
+    'minLon' : IDL.Float64,
+    'maxLat' : IDL.Float64,
+    'maxLon' : IDL.Float64,
+  });
+  const Shard = IDL.Record({
+    'sha256' : IDL.Opt(IDL.Text),
+    'area' : IDL.Text,
+    'bbox' : Bbox,
+    'osmDate' : IDL.Opt(IDL.Text),
+  });
+  const Error = IDL.Variant({
+    'CallFailed' : IDL.Text,
+    'Blocked' : IDL.Text,
+    'NotFound' : IDL.Text,
+    'NotAuthorized' : IDL.Text,
+    'LimitReached' : IDL.Text,
+    'InvalidData' : IDL.Text,
+    'RateLimited' : IDL.Text,
+    'Waiting' : IDL.Text,
+  });
+  const Result = IDL.Variant({ 'Ok' : Shard, 'Err' : Error });
+  const Result_1 = IDL.Variant({
+    'Ok' : IDL.Vec(IDL.Principal),
+    'Err' : Error,
+  });
+  const CopyState = IDL.Variant({
+    'Copying' : IDL.Null,
+    'Live' : IDL.Null,
+    'Installing' : IDL.Null,
+    'AwaitingData' : IDL.Null,
+    'MarkedForRemoval' : IDL.Null,
+  });
+  const Copy = IDL.Record({
+    'area' : IDL.Text,
+    'createdAtNs' : IDL.Nat64,
+    'state' : CopyState,
+    'subnet' : IDL.Opt(IDL.Principal),
+    'canister' : IDL.Principal,
+    'lastError' : IDL.Opt(IDL.Text),
+    'markedAtNs' : IDL.Opt(IDL.Nat64),
+  });
+  const Result_2 = IDL.Variant({ 'Ok' : Copy, 'Err' : Error });
+  const CoreState = IDL.Variant({ 'Live' : IDL.Null, 'Installing' : IDL.Null });
+  const CoreCanister = IDL.Record({
+    'syncedVersion' : IDL.Opt(IDL.Nat64),
+    'createdAtNs' : IDL.Nat64,
+    'cycles' : IDL.Opt(IDL.Nat),
+    'state' : CoreState,
+    'subnet' : IDL.Opt(IDL.Principal),
+    'canister' : IDL.Principal,
+    'lastError' : IDL.Opt(IDL.Text),
+  });
+  const Result_3 = IDL.Variant({ 'Ok' : CoreCanister, 'Err' : Error });
+  const AreaInfo = IDL.Record({
+    'sha256' : IDL.Opt(IDL.Text),
+    'area' : IDL.Text,
+    'bbox' : Bbox,
+    'copies' : IDL.Vec(IDL.Principal),
+    'osmDate' : IDL.Opt(IDL.Text),
+  });
+  const Areas = IDL.Record({
+    'ttlSeconds' : IDL.Nat32,
+    'areas' : IDL.Vec(AreaInfo),
+  });
+  const WasmKind = IDL.Variant({ 'Core' : IDL.Null, 'Worker' : IDL.Null });
+  const BeginWasmArgs = IDL.Record({
+    'sha256' : IDL.Text,
+    'kind' : IDL.Opt(WasmKind),
+    'size' : IDL.Nat64,
+  });
+  const WasmMeta = IDL.Record({
+    'sha256' : IDL.Text,
+    'size' : IDL.Nat64,
+    'ready' : IDL.Bool,
+  });
+  const Result_4 = IDL.Variant({ 'Ok' : WasmMeta, 'Err' : Error });
+  const Result_5 = IDL.Variant({ 'Ok' : IDL.Nat32, 'Err' : Error });
+  const UserKey = IDL.Record({
+    'user' : IDL.Principal,
+    'system' : IDL.Principal,
+  });
+  const Block = IDL.Record({
+    'who' : UserKey,
+    'atNs' : IDL.Nat64,
+    'load' : IDL.Opt(IDL.Float64),
+    'reason' : IDL.Text,
+  });
+  const CoreReport = IDL.Record({
+    'blocks' : IDL.Vec(Block),
+    'users' : IDL.Vec(IDL.Tuple(IDL.Text, IDL.Nat64)),
+    'rateLimited' : IDL.Vec(IDL.Principal),
+  });
+  const Result_6 = IDL.Variant({ 'Ok' : IDL.Null, 'Err' : Error });
+  const QueryTotals = IDL.Record({
+    'calls' : IDL.Nat,
+    'instructions' : IDL.Nat,
+    'responseBytes' : IDL.Nat,
+  });
+  const FeedArgs = IDL.Record({
+    'totals' : QueryTotals,
+    'canister' : IDL.Principal,
+  });
+  const System = IDL.Record({
+    'id' : IDL.Principal,
+    'demo' : IDL.Bool,
+    'blocked' : IDL.Bool,
+    'name' : IDL.Text,
+    'hourlyLimit' : IDL.Opt(IDL.Nat32),
+    'hourStartNs' : IDL.Nat64,
+    'passesThisHour' : IDL.Nat32,
+    'perMinute' : IDL.Nat32,
+  });
+  const BisectionRun = IDL.Record({
+    'endedAtNs' : IDL.Opt(IDL.Nat64),
+    'area' : IDL.Text,
+    'copyA' : IDL.Principal,
+    'copyB' : IDL.Principal,
+    'suspects' : IDL.Nat64,
+    'steps' : IDL.Nat32,
+    'stepStartedNs' : IDL.Nat64,
+  });
+  const PassState = IDL.Record({
+    'keys' : IDL.Vec(IDL.Tuple(IDL.Principal, IDL.Nat32, IDL.Bool)),
+    'cores' : IDL.Vec(CoreCanister),
+    'activePasses' : IDL.Nat64,
+    'systems' : IDL.Vec(System),
+    'blocks' : IDL.Vec(Block),
+    'bisections' : IDL.Vec(BisectionRun),
+  });
+  const Result_7 = IDL.Variant({ 'Ok' : PassState, 'Err' : Error });
+  const AreaLoad = IDL.Record({
+    'above' : IDL.Nat32,
+    'lastGrowthNs' : IDL.Opt(IDL.Nat64),
+    'belowSinceNs' : IDL.Opt(IDL.Nat64),
+    'area' : IDL.Text,
+  });
+  const Rates = IDL.Record({
+    'responseBytesPerS' : IDL.Float64,
+    'callsPerS' : IDL.Float64,
+    'instructionsPerS' : IDL.Float64,
+  });
+  const Reading = IDL.Record({
+    'atNs' : IDL.Nat64,
+    'sinceNs' : IDL.Opt(IDL.Nat64),
+    'cycles' : IDL.Nat,
+    'totals' : QueryTotals,
+    'canister' : IDL.Principal,
+    'rates' : IDL.Opt(Rates),
+  });
+  const Subnet = IDL.Record({ 'id' : IDL.Principal, 'sev' : IDL.Bool });
+  const Settings = IDL.Record({
+    'hInstructionsPerS' : IDL.Nat64,
+    'subnets' : IDL.Vec(Subnet),
+    'copyCycles' : IDL.Nat,
+    'passRequired' : IDL.Opt(IDL.Bool),
+    'mode' : Mode,
+    'coreCycles' : IDL.Opt(IDL.Nat),
+    'superadmins' : IDL.Vec(IDL.Principal),
+    'maxCopies' : IDL.Nat32,
+  });
+  const State = IDL.Record({
+    'coreWasm' : IDL.Opt(WasmMeta),
+    'shards' : IDL.Vec(Shard),
+    'lastRoundNs' : IDL.Opt(IDL.Nat64),
+    'cores' : IDL.Vec(CoreCanister),
+    'wasm' : IDL.Opt(WasmMeta),
+    'loads' : IDL.Vec(AreaLoad),
+    'cycles' : IDL.Nat,
+    'readings' : IDL.Vec(Reading),
+    'settings' : Settings,
+    'copies' : IDL.Vec(Copy),
+  });
+  const Result_8 = IDL.Variant({ 'Ok' : State, 'Err' : Error });
+  const HttpRequest = IDL.Record({
+    'url' : IDL.Text,
+    'method' : IDL.Text,
+    'body' : IDL.Vec(IDL.Nat8),
+    'headers' : IDL.Vec(IDL.Tuple(IDL.Text, IDL.Text)),
+    'certificate_version' : IDL.Opt(IDL.Nat16),
+  });
+  const HttpResponse = IDL.Record({
+    'body' : IDL.Vec(IDL.Nat8),
+    'headers' : IDL.Vec(IDL.Tuple(IDL.Text, IDL.Text)),
+    'upgrade' : IDL.Opt(IDL.Bool),
+    'status_code' : IDL.Nat16,
+  });
+  const NoticeKind = IDL.Variant({
+    'StatusFailed' : IDL.Null,
+    'BisectionStarted' : IDL.Null,
+    'CopyCreated' : IDL.Null,
+    'CopyDeleted' : IDL.Null,
+    'MaxCopiesReached' : IDL.Null,
+    'KeysFailed' : IDL.Null,
+    'CopyMarked' : IDL.Null,
+    'CopyUnmarked' : IDL.Null,
+    'CopyFailed' : IDL.Null,
+    'BisectionEnded' : IDL.Null,
+    'CoreFailed' : IDL.Null,
+    'SystemRateLimited' : IDL.Null,
+    'UserBlocked' : IDL.Null,
+    'CyclesLow' : IDL.Null,
+  });
+  const Notice = IDL.Record({
+    'id' : IDL.Nat64,
+    'area' : IDL.Opt(IDL.Text),
+    'atNs' : IDL.Nat64,
+    'kind' : NoticeKind,
+    'text' : IDL.Text,
+    'canister' : IDL.Opt(IDL.Principal),
+  });
+  const Result_9 = IDL.Variant({ 'Ok' : IDL.Vec(Notice), 'Err' : Error });
+  const Result_10 = IDL.Variant({ 'Ok' : System, 'Err' : Error });
+  const RoundReport = IDL.Record({
+    'atNs' : IDL.Nat64,
+    'actions' : IDL.Vec(IDL.Text),
+    'loads' : IDL.Vec(AreaLoad),
+    'readings' : IDL.Vec(Reading),
+  });
+  const Result_11 = IDL.Variant({ 'Ok' : RoundReport, 'Err' : Error });
+  const SettingsArgs = IDL.Record({
+    'hInstructionsPerS' : IDL.Nat64,
+    'subnets' : IDL.Vec(Subnet),
+    'copyCycles' : IDL.Nat,
+    'passRequired' : IDL.Opt(IDL.Bool),
+    'coreCycles' : IDL.Opt(IDL.Nat),
+    'maxCopies' : IDL.Nat32,
+  });
+  const Result_12 = IDL.Variant({ 'Ok' : Settings, 'Err' : Error });
+  const SystemArgs = IDL.Record({
+    'id' : IDL.Principal,
+    'demo' : IDL.Bool,
+    'blocked' : IDL.Bool,
+    'name' : IDL.Text,
+    'hourlyLimit' : IDL.Opt(IDL.Nat32),
+    'perMinute' : IDL.Nat32,
+  });
+  const Result_13 = IDL.Variant({ 'Ok' : IDL.Bool, 'Err' : Error });
+  const WasmChunkArgs = IDL.Record({
+    'kind' : IDL.Opt(WasmKind),
+    'offset' : IDL.Nat64,
+    'bytes' : IDL.Vec(IDL.Nat8),
+  });
+  return IDL.Service({
+    'addShard' : IDL.Func([IDL.Text, Bbox], [Result], []),
+    'addSuperadmin' : IDL.Func([IDL.Principal], [Result_1], []),
+    'advanceCopy' : IDL.Func([IDL.Principal], [Result_2], []),
+    'advanceCore' : IDL.Func([IDL.Principal], [Result_3], []),
+    'areas' : IDL.Func([], [Areas], ['query']),
+    'beginWasm' : IDL.Func([BeginWasmArgs], [Result_4], []),
+    'clearNotifications' : IDL.Func([IDL.Nat64], [Result_5], []),
+    'commitWasm' : IDL.Func([IDL.Opt(WasmKind)], [Result_4], []),
+    'coreReport' : IDL.Func([CoreReport], [Result_6], []),
+    'createCopy' : IDL.Func([IDL.Text], [Result_2], []),
+    'createCore' : IDL.Func([], [Result_3], []),
+    'deleteCopy' : IDL.Func([IDL.Principal], [Result_6], []),
+    'feedQueryStats' : IDL.Func([IDL.Vec(FeedArgs)], [Result_6], []),
+    'getPassState' : IDL.Func([], [Result_7], ['query']),
+    'getState' : IDL.Func([], [Result_8], ['query']),
+    'hasDependents' : IDL.Func([], [IDL.Bool], ['query']),
+    'http_request' : IDL.Func([HttpRequest], [HttpResponse], ['query']),
+    'issuerFor' : IDL.Func(
+        [IDL.Principal],
+        [IDL.Opt(IDL.Principal)],
+        ['query'],
+      ),
+    'listDependents' : IDL.Func([], [IDL.Vec(IDL.Principal)], ['query']),
+    'markCopy' : IDL.Func([IDL.Principal], [Result_2], []),
+    'notifications' : IDL.Func([], [Result_9], ['query']),
+    'removeSuperadmin' : IDL.Func([IDL.Principal], [Result_1], []),
+    'removeSystem' : IDL.Func([IDL.Principal], [Result_10], []),
+    'runRound' : IDL.Func([], [Result_11], []),
+    'setSettings' : IDL.Func([SettingsArgs], [Result_12], []),
+    'setSystem' : IDL.Func([SystemArgs], [Result_10], []),
+    'unblockUser' : IDL.Func([UserKey], [Result_13], []),
+    'upgradeCopy' : IDL.Func([IDL.Principal], [Result_2], []),
+    'upgradeCore' : IDL.Func([IDL.Principal], [Result_3], []),
+    'wasmChunk' : IDL.Func([WasmChunkArgs], [Result_6], []),
+  });
+};
+export const init = ({ IDL }) => {
+  const Mode = IDL.Variant({
+    'Local' : IDL.Null,
+    'Stage' : IDL.Null,
+    'Prod' : IDL.Null,
+  });
+  const InitArgs = IDL.Record({
+    'mode' : Mode,
+    'superadmins' : IDL.Vec(IDL.Principal),
+  });
+  return [InitArgs];
+};

package/declarations/map-routes-core/map-routes-core.did

@@ -0,0 +1,107 @@
+// An area as the core needs it to issue a pass.
+type AreaPasses = record {
+  area : text;
+  bbox : Bbox;
+  // Short passes: the area is under load or in a bisection.
+  short : bool;
+  split : opt Split;
+  // The live copies with a key; none = no pass yet (`Waiting`).
+  copies : vec CopyKey;
+};
+// A rectangle in degrees, edges included.
+type Bbox = record {
+  minLat : float64;
+  minLon : float64;
+  maxLat : float64;
+  maxLon : float64;
+};
+// Stored: a blocked user (key = system/user). The coordinator lifts it (`setBlock`).
+type Block = record {
+  who : UserKey;
+  atNs : nat64;
+  load : opt float64;
+  reason : text;
+};
+// A live copy and the newest key it holds (passes are signed with it).
+type CopyKey = record { key : blob; copy : principal; keyId : nat32 };
+type CoreStats = record {
+  areas : nat32;
+  activePasses : nat64;
+  version : nat64;
+  systems : nat32;
+  blocks : nat64;
+};
+type Error = variant {
+  // The user gets no pass: the reason and whom to contact.
+  Blocked : text;
+  NotFound : text;
+  NotAuthorized : text;
+  InvalidData : text;
+  // The system asks too often (or the demo used its hour): try later.
+  RateLimited : text;
+  // Waits for something outside (named): e.g. the keys of the copies.
+  Waiting : text;
+};
+type InitArgs = record { mode : Mode; coordinator : principal };
+type IssuePassArgs = record {
+  area : text;
+  // Cut to the bbox of the area.
+  bbox : Bbox;
+  // The principal that will call the worker (`caller` of the query).
+  user : principal;
+  // The registered system the caller belongs to, when the caller is not a system itself:
+  // the coordinator of the caller's group (e.g. a core of Tigi names the Tigi coordinator).
+  // The pass core asks that coordinator once (`isGroupCore`) and remembers the answer.
+  system : opt principal;
+};
+type Mode = variant { Local; Stage; Prod };
+type PassInfo = record {
+  area : text;
+  bbox : Bbox;
+  // The copy to ask: the pass is valid there only.
+  copy : principal;
+  pass : blob;
+  validUntilNs : nat64;
+};
+type Result = variant { Ok : opt UserKey; Err : Error };
+type Result_1 = variant { Ok : nat64; Err : Error };
+type Result_2 = variant { Ok; Err : Error };
+type Result_3 = variant { Ok : PassInfo; Err : Error };
+// Stored (key 0): what the coordinator sent last. A newer `version` replaces it.
+type Snapshot = record {
+  areas : vec AreaPasses;
+  version : nat64;
+  systems : vec SystemInfo;
+};
+// The two copies of a running bisection of an area (the lists of users stay here).
+type Split = record { copyA : principal; copyB : principal };
+type SystemInfo = record {
+  id : principal;
+  demo : bool;
+  blocked : bool;
+  name : text;
+  hourlyLimit : opt nat32;
+  perMinute : nat32;
+};
+type UserKey = record { user : principal; system : principal };
+service : (InitArgs) -> {
+  // The one suspect left is blocked; answers it (none when this core holds none).
+  bisectionBlock : (text, text, opt float64) -> (Result);
+  // The half on copy A (`heavyA`) or on copy B carried the surplus: it stays and is split again.
+  // Answers the suspects left in this core.
+  bisectionStep : (text, bool) -> (Result_1);
+  endBisection : (text) -> (Result_2);
+  // A registered system — or a core of its group, naming the system's coordinator — asks for
+  // the pass of its user: valid on one copy, for the bbox cut to the area, for 15 min (2 min
+  // under load, in a bisection and for demo). The same valid pass comes back without a write.
+  issuePass : (IssuePassArgs) -> (Result_3);
+  // A block from the coordinator (a superadmin, a bisection in another core), or its end.
+  setBlock : (UserKey, opt Block) -> (Result_2);
+  // A bisection of `area` over two copies: the users with a valid pass there, split in halves.
+  // Answers their number in this core.
+  startBisection : (text, Split) -> (Result_1);
+  // Counts only (no user, no key): for the coordinator's front and the checks.
+  stats : () -> (CoreStats) query;
+  // The coordinator's snapshot: replaces the held one when newer. Answers the version held.
+  sync : (Snapshot) -> (Result_1);
+}

package/declarations/map-routes-core/map-routes-core.did.d.ts

@@ -0,0 +1,171 @@
+import type { Principal } from '@icp-sdk/core/principal';
+import type { ActorMethod } from '@icp-sdk/core/agent';
+import type { IDL } from '@icp-sdk/core/candid';
+
+/**
+ * An area as the core needs it to issue a pass.
+ */
+export interface AreaPasses {
+  'area' : string,
+  'bbox' : Bbox,
+  /**
+   * Short passes: the area is under load or in a bisection.
+   */
+  'short' : boolean,
+  'split' : [] | [Split],
+  /**
+   * The live copies with a key; none = no pass yet (`Waiting`).
+   */
+  'copies' : Array<CopyKey>,
+}
+/**
+ * A rectangle in degrees, edges included.
+ */
+export interface Bbox {
+  'minLat' : number,
+  'minLon' : number,
+  'maxLat' : number,
+  'maxLon' : number,
+}
+/**
+ * Stored: a blocked user (key = system/user). The coordinator lifts it (`setBlock`).
+ */
+export interface Block {
+  'who' : UserKey,
+  'atNs' : bigint,
+  'load' : [] | [number],
+  'reason' : string,
+}
+/**
+ * A live copy and the newest key it holds (passes are signed with it).
+ */
+export interface CopyKey {
+  'key' : Uint8Array | number[],
+  'copy' : Principal,
+  'keyId' : number,
+}
+export interface CoreStats {
+  'areas' : number,
+  'activePasses' : bigint,
+  'version' : bigint,
+  'systems' : number,
+  'blocks' : bigint,
+}
+export type Error = {
+    /**
+     * The user gets no pass: the reason and whom to contact.
+     */
+    'Blocked' : string
+  } |
+  { 'NotFound' : string } |
+  { 'NotAuthorized' : string } |
+  { 'InvalidData' : string } |
+  {
+    /**
+     * The system asks too often (or the demo used its hour): try later.
+     */
+    'RateLimited' : string
+  } |
+  {
+    /**
+     * Waits for something outside (named): e.g. the keys of the copies.
+     */
+    'Waiting' : string
+  };
+export interface InitArgs { 'mode' : Mode, 'coordinator' : Principal }
+export interface IssuePassArgs {
+  'area' : string,
+  /**
+   * Cut to the bbox of the area.
+   */
+  'bbox' : Bbox,
+  /**
+   * The principal that will call the worker (`caller` of the query).
+   */
+  'user' : Principal,
+  /**
+   * The registered system the caller belongs to, when the caller is not a system itself:
+   * the coordinator of the caller's group (e.g. a core of Tigi names the Tigi coordinator).
+   * The pass core asks that coordinator once (`isGroupCore`) and remembers the answer.
+   */
+  'system' : [] | [Principal],
+}
+export type Mode = { 'Local' : null } |
+  { 'Stage' : null } |
+  { 'Prod' : null };
+export interface PassInfo {
+  'area' : string,
+  'bbox' : Bbox,
+  /**
+   * The copy to ask: the pass is valid there only.
+   */
+  'copy' : Principal,
+  'pass' : Uint8Array | number[],
+  'validUntilNs' : bigint,
+}
+export type Result = { 'Ok' : [] | [UserKey] } |
+  { 'Err' : Error };
+export type Result_1 = { 'Ok' : bigint } |
+  { 'Err' : Error };
+export type Result_2 = { 'Ok' : null } |
+  { 'Err' : Error };
+export type Result_3 = { 'Ok' : PassInfo } |
+  { 'Err' : Error };
+/**
+ * Stored (key 0): what the coordinator sent last. A newer `version` replaces it.
+ */
+export interface Snapshot {
+  'areas' : Array<AreaPasses>,
+  'version' : bigint,
+  'systems' : Array<SystemInfo>,
+}
+/**
+ * The two copies of a running bisection of an area (the lists of users stay here).
+ */
+export interface Split { 'copyA' : Principal, 'copyB' : Principal }
+export interface SystemInfo {
+  'id' : Principal,
+  'demo' : boolean,
+  'blocked' : boolean,
+  'name' : string,
+  'hourlyLimit' : [] | [number],
+  'perMinute' : number,
+}
+export interface UserKey { 'user' : Principal, 'system' : Principal }
+export interface _SERVICE {
+  /**
+   * The one suspect left is blocked; answers it (none when this core holds none).
+   */
+  'bisectionBlock' : ActorMethod<[string, string, [] | [number]], Result>,
+  /**
+   * The half on copy A (`heavyA`) or on copy B carried the surplus: it stays and is split again.
+   * Answers the suspects left in this core.
+   */
+  'bisectionStep' : ActorMethod<[string, boolean], Result_1>,
+  'endBisection' : ActorMethod<[string], Result_2>,
+  /**
+   * A registered system — or a core of its group, naming the system's coordinator — asks for
+   * the pass of its user: valid on one copy, for the bbox cut to the area, for 15 min (2 min
+   * under load, in a bisection and for demo). The same valid pass comes back without a write.
+   */
+  'issuePass' : ActorMethod<[IssuePassArgs], Result_3>,
+  /**
+   * A block from the coordinator (a superadmin, a bisection in another core), or its end.
+   */
+  'setBlock' : ActorMethod<[UserKey, [] | [Block]], Result_2>,
+  /**
+   * A bisection of `area` over two copies: the users with a valid pass there, split in halves.
+   * Answers their number in this core.
+   */
+  'startBisection' : ActorMethod<[string, Split], Result_1>,
+  /**
+   * Counts only (no user, no key): for the coordinator's front and the checks.
+   */
+  'stats' : ActorMethod<[], CoreStats>,
+  /**
+   * The coordinator's snapshot: replaces the held one when newer. Answers the version held.
+   */
+  'sync' : ActorMethod<[Snapshot], Result_1>,
+}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];

package/declarations/map-routes-core/map-routes-core.did.js

@@ -0,0 +1,108 @@
+export const idlFactory = ({ IDL }) => {
+  const Mode = IDL.Variant({
+    'Local' : IDL.Null,
+    'Stage' : IDL.Null,
+    'Prod' : IDL.Null,
+  });
+  const InitArgs = IDL.Record({ 'mode' : Mode, 'coordinator' : IDL.Principal });
+  const UserKey = IDL.Record({
+    'user' : IDL.Principal,
+    'system' : IDL.Principal,
+  });
+  const Error = IDL.Variant({
+    'Blocked' : IDL.Text,
+    'NotFound' : IDL.Text,
+    'NotAuthorized' : IDL.Text,
+    'InvalidData' : IDL.Text,
+    'RateLimited' : IDL.Text,
+    'Waiting' : IDL.Text,
+  });
+  const Result = IDL.Variant({ 'Ok' : IDL.Opt(UserKey), 'Err' : Error });
+  const Result_1 = IDL.Variant({ 'Ok' : IDL.Nat64, 'Err' : Error });
+  const Result_2 = IDL.Variant({ 'Ok' : IDL.Null, 'Err' : Error });
+  const Bbox = IDL.Record({
+    'minLat' : IDL.Float64,
+    'minLon' : IDL.Float64,
+    'maxLat' : IDL.Float64,
+    'maxLon' : IDL.Float64,
+  });
+  const IssuePassArgs = IDL.Record({
+    'area' : IDL.Text,
+    'bbox' : Bbox,
+    'user' : IDL.Principal,
+    'system' : IDL.Opt(IDL.Principal),
+  });
+  const PassInfo = IDL.Record({
+    'area' : IDL.Text,
+    'bbox' : Bbox,
+    'copy' : IDL.Principal,
+    'pass' : IDL.Vec(IDL.Nat8),
+    'validUntilNs' : IDL.Nat64,
+  });
+  const Result_3 = IDL.Variant({ 'Ok' : PassInfo, 'Err' : Error });
+  const Block = IDL.Record({
+    'who' : UserKey,
+    'atNs' : IDL.Nat64,
+    'load' : IDL.Opt(IDL.Float64),
+    'reason' : IDL.Text,
+  });
+  const Split = IDL.Record({
+    'copyA' : IDL.Principal,
+    'copyB' : IDL.Principal,
+  });
+  const CoreStats = IDL.Record({
+    'areas' : IDL.Nat32,
+    'activePasses' : IDL.Nat64,
+    'version' : IDL.Nat64,
+    'systems' : IDL.Nat32,
+    'blocks' : IDL.Nat64,
+  });
+  const CopyKey = IDL.Record({
+    'key' : IDL.Vec(IDL.Nat8),
+    'copy' : IDL.Principal,
+    'keyId' : IDL.Nat32,
+  });
+  const AreaPasses = IDL.Record({
+    'area' : IDL.Text,
+    'bbox' : Bbox,
+    'short' : IDL.Bool,
+    'split' : IDL.Opt(Split),
+    'copies' : IDL.Vec(CopyKey),
+  });
+  const SystemInfo = IDL.Record({
+    'id' : IDL.Principal,
+    'demo' : IDL.Bool,
+    'blocked' : IDL.Bool,
+    'name' : IDL.Text,
+    'hourlyLimit' : IDL.Opt(IDL.Nat32),
+    'perMinute' : IDL.Nat32,
+  });
+  const Snapshot = IDL.Record({
+    'areas' : IDL.Vec(AreaPasses),
+    'version' : IDL.Nat64,
+    'systems' : IDL.Vec(SystemInfo),
+  });
+  return IDL.Service({
+    'bisectionBlock' : IDL.Func(
+        [IDL.Text, IDL.Text, IDL.Opt(IDL.Float64)],
+        [Result],
+        [],
+      ),
+    'bisectionStep' : IDL.Func([IDL.Text, IDL.Bool], [Result_1], []),
+    'endBisection' : IDL.Func([IDL.Text], [Result_2], []),
+    'issuePass' : IDL.Func([IssuePassArgs], [Result_3], []),
+    'setBlock' : IDL.Func([UserKey, IDL.Opt(Block)], [Result_2], []),
+    'startBisection' : IDL.Func([IDL.Text, Split], [Result_1], []),
+    'stats' : IDL.Func([], [CoreStats], ['query']),
+    'sync' : IDL.Func([Snapshot], [Result_1], []),
+  });
+};
+export const init = ({ IDL }) => {
+  const Mode = IDL.Variant({
+    'Local' : IDL.Null,
+    'Stage' : IDL.Null,
+    'Prod' : IDL.Null,
+  });
+  const InitArgs = IDL.Record({ 'mode' : Mode, 'coordinator' : IDL.Principal });
+  return [InitArgs];
+};