ic-mops 0.40.0 → 0.41.0

package/bundle/declarations/bench/bench.did

@@ -0,0 +1,26 @@
+type anon_class_10_1 = 
+ service {
+   getSchema: () -> (BenchSchema) query;
+   getStats: () -> (BenchResult) query;
+   init: () -> (BenchSchema);
+   runCellQuery: (nat, nat) -> (BenchResult) query;
+   runCellUpdate: (nat, nat) -> (BenchResult);
+   runCellUpdateAwait: (nat, nat) -> (BenchResult);
+ };
+type BenchSchema = 
+ record {
+   cols: vec text;
+   description: text;
+   name: text;
+   rows: vec text;
+ };
+type BenchResult = 
+ record {
+   instructions: int;
+   rts_collector_instructions: int;
+   rts_heap_size: int;
+   rts_memory_size: int;
+   rts_mutator_instructions: int;
+   rts_total_allocation: int;
+ };
+service : () -> anon_class_10_1

package/bundle/declarations/bench/bench.did.d.ts

@@ -0,0 +1,29 @@
+import type { Principal } from '@dfinity/principal';
+import type { ActorMethod } from '@dfinity/agent';
+import type { IDL } from '@dfinity/candid';
+
+export interface BenchResult {
+  'instructions' : bigint,
+  'rts_memory_size' : bigint,
+  'rts_total_allocation' : bigint,
+  'rts_collector_instructions' : bigint,
+  'rts_mutator_instructions' : bigint,
+  'rts_heap_size' : bigint,
+}
+export interface BenchSchema {
+  'cols' : Array<string>,
+  'name' : string,
+  'rows' : Array<string>,
+  'description' : string,
+}
+export interface anon_class_10_1 {
+  'getSchema' : ActorMethod<[], BenchSchema>,
+  'getStats' : ActorMethod<[], BenchResult>,
+  'init' : ActorMethod<[], BenchSchema>,
+  'runCellQuery' : ActorMethod<[bigint, bigint], BenchResult>,
+  'runCellUpdate' : ActorMethod<[bigint, bigint], BenchResult>,
+  'runCellUpdateAwait' : ActorMethod<[bigint, bigint], BenchResult>,
+}
+export interface _SERVICE extends anon_class_10_1 {}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: ({ IDL }: { IDL: IDL }) => IDL.Type[];

package/bundle/declarations/bench/bench.did.js

@@ -0,0 +1,26 @@
+export const idlFactory = ({ IDL }) => {
+  const BenchSchema = IDL.Record({
+    'cols' : IDL.Vec(IDL.Text),
+    'name' : IDL.Text,
+    'rows' : IDL.Vec(IDL.Text),
+    'description' : IDL.Text,
+  });
+  const BenchResult = IDL.Record({
+    'instructions' : IDL.Int,
+    'rts_memory_size' : IDL.Int,
+    'rts_total_allocation' : IDL.Int,
+    'rts_collector_instructions' : IDL.Int,
+    'rts_mutator_instructions' : IDL.Int,
+    'rts_heap_size' : IDL.Int,
+  });
+  const anon_class_10_1 = IDL.Service({
+    'getSchema' : IDL.Func([], [BenchSchema], ['query']),
+    'getStats' : IDL.Func([], [BenchResult], ['query']),
+    'init' : IDL.Func([], [BenchSchema], []),
+    'runCellQuery' : IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], ['query']),
+    'runCellUpdate' : IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], []),
+    'runCellUpdateAwait' : IDL.Func([IDL.Nat, IDL.Nat], [BenchResult], []),
+  });
+  return anon_class_10_1;
+};
+export const init = ({ IDL }) => { return []; };

package/bundle/declarations/bench/index.d.ts

@@ -0,0 +1,50 @@
+import type {
+  ActorSubclass,
+  HttpAgentOptions,
+  ActorConfig,
+  Agent,
+} from "@dfinity/agent";
+import type { Principal } from "@dfinity/principal";
+import type { IDL } from "@dfinity/candid";
+
+import { _SERVICE } from './bench.did';
+
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const canisterId: string;
+
+export declare interface CreateActorOptions {
+  /**
+   * @see {@link Agent}
+   */
+  agent?: Agent;
+  /**
+   * @see {@link HttpAgentOptions}
+   */
+  agentOptions?: HttpAgentOptions;
+  /**
+   * @see {@link ActorConfig}
+   */
+  actorOptions?: ActorConfig;
+}
+
+/**
+ * Intializes an {@link ActorSubclass}, configured with the provided SERVICE interface of a canister.
+ * @constructs {@link ActorSubClass}
+ * @param {string | Principal} canisterId - ID of the canister the {@link Actor} will talk to
+ * @param {CreateActorOptions} options - see {@link CreateActorOptions}
+ * @param {CreateActorOptions["agent"]} options.agent - a pre-configured agent you'd like to use. Supercedes agentOptions
+ * @param {CreateActorOptions["agentOptions"]} options.agentOptions - options to set up a new agent
+ * @see {@link HttpAgentOptions}
+ * @param {CreateActorOptions["actorOptions"]} options.actorOptions - options for the Actor
+ * @see {@link ActorConfig}
+ */
+export declare const createActor: (
+  canisterId: string | Principal,
+  options?: CreateActorOptions
+) => ActorSubclass<_SERVICE>;
+
+/**
+ * Intialized Actor using default settings, ready to talk to a canister using its candid interface
+ * @constructs {@link ActorSubClass}
+ */
+export declare const bench: ActorSubclass<_SERVICE>;

package/bundle/declarations/bench/index.js

@@ -0,0 +1,41 @@
+import { Actor, HttpAgent } from "@dfinity/agent";
+
+// Imports and re-exports candid interface
+import { idlFactory } from "./bench.did.js";
+export { idlFactory } from "./bench.did.js";
+
+/* CANISTER_ID is replaced by webpack based on node environment
+ * Note: canister environment variable will be standardized as
+ * process.env.CANISTER_ID_<CANISTER_NAME_UPPERCASE>
+ * beginning in dfx 0.15.0
+ */
+export const canisterId =
+  process.env.CANISTER_ID_BENCH ||
+  process.env.BENCH_CANISTER_ID;
+
+export const createActor = (canisterId, options = {}) => {
+  const agent = options.agent || new HttpAgent({ ...options.agentOptions });
+
+  if (options.agent && options.agentOptions) {
+    console.warn(
+      "Detected both agent and agentOptions passed to createActor. Ignoring agentOptions and proceeding with the provided agent."
+    );
+  }
+
+  // Fetch root key for certificate validation during development
+  if (process.env.DFX_NETWORK !== "ic") {
+    agent.fetchRootKey().catch((err) => {
+      console.warn(
+        "Unable to fetch root key. Check to ensure that your local replica is running"
+      );
+      console.error(err);
+    });
+  }
+
+  // Creates an actor with using the candid interface and the HttpAgent
+  return Actor.createActor(idlFactory, {
+    agent,
+    canisterId,
+    ...options.actorOptions,
+  });
+};

package/bundle/declarations/main/index.d.ts

@@ -0,0 +1,50 @@
+import type {
+  ActorSubclass,
+  HttpAgentOptions,
+  ActorConfig,
+  Agent,
+} from "@dfinity/agent";
+import type { Principal } from "@dfinity/principal";
+import type { IDL } from "@dfinity/candid";
+
+import { _SERVICE } from './main.did';
+
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const canisterId: string;
+
+export declare interface CreateActorOptions {
+  /**
+   * @see {@link Agent}
+   */
+  agent?: Agent;
+  /**
+   * @see {@link HttpAgentOptions}
+   */
+  agentOptions?: HttpAgentOptions;
+  /**
+   * @see {@link ActorConfig}
+   */
+  actorOptions?: ActorConfig;
+}
+
+/**
+ * Intializes an {@link ActorSubclass}, configured with the provided SERVICE interface of a canister.
+ * @constructs {@link ActorSubClass}
+ * @param {string | Principal} canisterId - ID of the canister the {@link Actor} will talk to
+ * @param {CreateActorOptions} options - see {@link CreateActorOptions}
+ * @param {CreateActorOptions["agent"]} options.agent - a pre-configured agent you'd like to use. Supercedes agentOptions
+ * @param {CreateActorOptions["agentOptions"]} options.agentOptions - options to set up a new agent
+ * @see {@link HttpAgentOptions}
+ * @param {CreateActorOptions["actorOptions"]} options.actorOptions - options for the Actor
+ * @see {@link ActorConfig}
+ */
+export declare const createActor: (
+  canisterId: string | Principal,
+  options?: CreateActorOptions
+) => ActorSubclass<_SERVICE>;
+
+/**
+ * Intialized Actor using default settings, ready to talk to a canister using its candid interface
+ * @constructs {@link ActorSubClass}
+ */
+export declare const main: ActorSubclass<_SERVICE>;

package/bundle/declarations/main/index.js

@@ -0,0 +1,41 @@
+import { Actor, HttpAgent } from "@dfinity/agent";
+
+// Imports and re-exports candid interface
+import { idlFactory } from "./main.did.js";
+export { idlFactory } from "./main.did.js";
+
+/* CANISTER_ID is replaced by webpack based on node environment
+ * Note: canister environment variable will be standardized as
+ * process.env.CANISTER_ID_<CANISTER_NAME_UPPERCASE>
+ * beginning in dfx 0.15.0
+ */
+export const canisterId =
+  process.env.CANISTER_ID_MAIN ||
+  process.env.MAIN_CANISTER_ID;
+
+export const createActor = (canisterId, options = {}) => {
+  const agent = options.agent || new HttpAgent({ ...options.agentOptions });
+
+  if (options.agent && options.agentOptions) {
+    console.warn(
+      "Detected both agent and agentOptions passed to createActor. Ignoring agentOptions and proceeding with the provided agent."
+    );
+  }
+
+  // Fetch root key for certificate validation during development
+  if (process.env.DFX_NETWORK !== "ic") {
+    agent.fetchRootKey().catch((err) => {
+      console.warn(
+        "Unable to fetch root key. Check to ensure that your local replica is running"
+      );
+      console.error(err);
+    });
+  }
+
+  // Creates an actor with using the candid interface and the HttpAgent
+  return Actor.createActor(idlFactory, {
+    agent,
+    canisterId,
+    ...options.actorOptions,
+  });
+};

package/bundle/declarations/main/main.did

@@ -0,0 +1,426 @@
+type User__1 = 
+ record {
+   displayName: text;
+   email: text;
+   emailVerified: bool;
+   github: text;
+   githubVerified: bool;
+   id: principal;
+   name: text;
+   site: text;
+   twitter: text;
+   twitterVerified: bool;
+ };
+type User = 
+ record {
+   displayName: text;
+   email: text;
+   emailVerified: bool;
+   github: text;
+   githubVerified: bool;
+   id: principal;
+   name: text;
+   site: text;
+   twitter: text;
+   twitterVerified: bool;
+ };
+type Time = int;
+type Text = text;
+type TestsChanges = 
+ record {
+   addedNames: vec text;
+   removedNames: vec text;
+ };
+type TestStats__1 = 
+ record {
+   passed: nat;
+   passedNames: vec text;
+ };
+type TestStats = 
+ record {
+   passed: nat;
+   passedNames: vec text;
+ };
+type StreamingToken = blob;
+type StreamingStrategy = variant {
+                           Callback:
+                            record {
+                              callback: StreamingCallback;
+                              token: StreamingToken;
+                            };};
+type StreamingCallbackResponse = 
+ record {
+   body: blob;
+   token: opt StreamingToken;
+ };
+type StreamingCallback = func (StreamingToken) ->
+                          (opt StreamingCallbackResponse) query;
+type StorageStats = 
+ record {
+   cyclesBalance: nat;
+   fileCount: nat;
+   memorySize: nat;
+ };
+type StorageId = principal;
+type SemverPart = 
+ variant {
+   major;
+   minor;
+   patch;
+ };
+type Script = 
+ record {
+   name: text;
+   value: text;
+ };
+type Result_8 = 
+ variant {
+   err: Err;
+   ok: vec record {
+             FileId;
+             blob;
+           };
+ };
+type Result_7 = 
+ variant {
+   err: Err;
+   ok: vec FileId;
+ };
+type Result_6 = 
+ variant {
+   err: Err;
+   ok: vec record {
+             PackageName;
+             PackageVersion;
+           };
+ };
+type Result_5 = 
+ variant {
+   err: Err;
+   ok: PackageVersion;
+ };
+type Result_4 = 
+ variant {
+   err: Err;
+   ok: PackageDetails;
+ };
+type Result_3 = 
+ variant {
+   err: Err;
+   ok: FileId;
+ };
+type Result_2 = 
+ variant {
+   err: Err;
+   ok: PublishingId;
+ };
+type Result_1 = 
+ variant {
+   err: text;
+   ok;
+ };
+type Result = 
+ variant {
+   err: Err;
+   ok;
+ };
+type Response = 
+ record {
+   body: blob;
+   headers: vec Header;
+   status_code: nat16;
+   streaming_strategy: opt StreamingStrategy;
+   upgrade: opt bool;
+ };
+type Request = 
+ record {
+   body: blob;
+   certificate_version: opt nat16;
+   headers: vec Header;
+   method: text;
+   url: text;
+ };
+type PublishingId = text;
+type PageCount = nat;
+type PackageVersion = text;
+type PackageSummary__1 = 
+ record {
+   config: PackageConfigV2__1;
+   downloadsInLast30Days: nat;
+   downloadsInLast7Days: nat;
+   downloadsTotal: nat;
+   owner: principal;
+   ownerInfo: User;
+   publication: PackagePublication;
+   quality: PackageQuality;
+ };
+type PackageSummaryWithChanges__1 = 
+ record {
+   changes: PackageChanges;
+   config: PackageConfigV2__1;
+   downloadsInLast30Days: nat;
+   downloadsInLast7Days: nat;
+   downloadsTotal: nat;
+   owner: principal;
+   ownerInfo: User;
+   publication: PackagePublication;
+   quality: PackageQuality;
+ };
+type PackageSummaryWithChanges = 
+ record {
+   changes: PackageChanges;
+   config: PackageConfigV2__1;
+   downloadsInLast30Days: nat;
+   downloadsInLast7Days: nat;
+   downloadsTotal: nat;
+   owner: principal;
+   ownerInfo: User;
+   publication: PackagePublication;
+   quality: PackageQuality;
+ };
+type PackageSummary = 
+ record {
+   config: PackageConfigV2__1;
+   downloadsInLast30Days: nat;
+   downloadsInLast7Days: nat;
+   downloadsTotal: nat;
+   owner: principal;
+   ownerInfo: User;
+   publication: PackagePublication;
+   quality: PackageQuality;
+ };
+type PackageQuality = 
+ record {
+   depsStatus: DepsStatus;
+   hasDescription: bool;
+   hasDocumentation: bool;
+   hasKeywords: bool;
+   hasLicense: bool;
+   hasReleaseNotes: bool;
+   hasRepository: bool;
+   hasTests: bool;
+ };
+type PackagePublication = 
+ record {
+   storage: principal;
+   time: Time;
+   user: principal;
+ };
+type PackageName__1 = text;
+type PackageName = text;
+type PackageId = text;
+type PackageFileStatsPublic = 
+ record {
+   sourceFiles: nat;
+   sourceSize: nat;
+ };
+type PackageDetails = 
+ record {
+   benchmarks: Benchmarks__1;
+   changes: PackageChanges;
+   config: PackageConfigV2__1;
+   dependents: vec PackageSummary__1;
+   deps: vec PackageSummary__1;
+   devDeps: vec PackageSummary__1;
+   downloadTrend: vec DownloadsSnapshot;
+   downloadsInLast30Days: nat;
+   downloadsInLast7Days: nat;
+   downloadsTotal: nat;
+   fileStats: PackageFileStatsPublic;
+   owner: principal;
+   ownerInfo: User;
+   publication: PackagePublication;
+   quality: PackageQuality;
+   testStats: TestStats__1;
+   versionHistory: vec PackageSummaryWithChanges__1;
+ };
+type PackageConfigV2__1 = 
+ record {
+   baseDir: text;
+   dependencies: vec DependencyV2;
+   description: text;
+   devDependencies: vec DependencyV2;
+   dfx: text;
+   documentation: text;
+   donation: text;
+   homepage: text;
+   keywords: vec text;
+   license: text;
+   moc: text;
+   name: PackageName__1;
+   readme: text;
+   repository: text;
+   scripts: vec Script;
+   version: text;
+ };
+type PackageConfigV2 = 
+ record {
+   baseDir: text;
+   dependencies: vec DependencyV2;
+   description: text;
+   devDependencies: vec DependencyV2;
+   dfx: text;
+   documentation: text;
+   donation: text;
+   homepage: text;
+   keywords: vec text;
+   license: text;
+   moc: text;
+   name: PackageName__1;
+   readme: text;
+   repository: text;
+   scripts: vec Script;
+   version: text;
+ };
+type PackageChanges = 
+ record {
+   curBenchmarks: Benchmarks__1;
+   deps: vec DepChange;
+   devDeps: vec DepChange;
+   notes: text;
+   prevBenchmarks: Benchmarks__1;
+   tests: TestsChanges;
+ };
+type Main = 
+ service {
+   backup: () -> ();
+   computeHashesForExistingFiles: () -> ();
+   finishPublish: (PublishingId) -> (Result);
+   getApiVersion: () -> (Text) query;
+   getBackupCanisterId: () -> (principal) query;
+   getDefaultPackages: (text) ->
+    (vec record {
+           PackageName;
+           PackageVersion;
+         }) query;
+   getDownloadTrendByPackageId: (PackageId) ->
+    (vec DownloadsSnapshot__1) query;
+   getDownloadTrendByPackageName: (PackageName) ->
+    (vec DownloadsSnapshot__1) query;
+   getFileHashes: (PackageName, PackageVersion) -> (Result_8);
+   getFileHashesByPackageIds: (vec PackageId) ->
+    (vec record {
+           PackageId;
+           vec record {
+                 FileId;
+                 blob;
+               };
+         });
+   getFileHashesQuery: (PackageName, PackageVersion) -> (Result_8) query;
+   getFileIds: (PackageName, PackageVersion) -> (Result_7) query;
+   getHighestSemverBatch:
+    (vec record {
+           PackageName;
+           PackageVersion;
+           SemverPart;
+         }) -> (Result_6) query;
+   getHighestVersion: (PackageName) -> (Result_5) query;
+   getMostDownloadedPackages: () -> (vec PackageSummary) query;
+   getMostDownloadedPackagesIn7Days: () -> (vec PackageSummary) query;
+   getNewPackages: () -> (vec PackageSummary) query;
+   getPackageDetails: (PackageName, PackageVersion) -> (Result_4) query;
+   getPackagesByCategory: () -> (vec record {
+                                       text;
+                                       vec PackageSummary;
+                                     }) query;
+   getRecentlyUpdatedPackages: () -> (vec PackageSummaryWithChanges) query;
+   getStoragesStats: () -> (vec record {
+                                  StorageId;
+                                  StorageStats;
+                                }) query;
+   getTotalDownloads: () -> (nat) query;
+   getTotalPackages: () -> (nat) query;
+   getUser: (principal) -> (opt User__1) query;
+   http_request: (Request) -> (Response) query;
+   notifyInstall: (PackageName, PackageVersion) -> () oneway;
+   notifyInstalls: (vec record {
+                          PackageName;
+                          PackageVersion;
+                        }) -> () oneway;
+   restore: (nat) -> ();
+   search: (Text, opt nat, opt nat) -> (vec PackageSummary, PageCount) query;
+   setUserProp: (text, text) -> (Result_1);
+   startFileUpload: (PublishingId, Text, nat, blob) -> (Result_3);
+   startPublish: (PackageConfigV2) -> (Result_2);
+   transferOwnership: (PackageName, principal) -> (Result_1);
+   transformRequest: (HttpTransformArg) -> (HttpResponse) query;
+   uploadBenchmarks: (PublishingId, Benchmarks) -> (Result);
+   uploadFileChunk: (PublishingId, FileId, nat, blob) -> (Result);
+   uploadNotes: (PublishingId, text) -> (Result);
+   uploadTestStats: (PublishingId, TestStats) -> (Result);
+ };
+type HttpTransformArg = 
+ record {
+   context: blob;
+   response: HttpResponse;
+ };
+type HttpResponse = 
+ record {
+   body: blob;
+   headers: vec HttpHeader;
+   status: nat;
+ };
+type HttpHeader = 
+ record {
+   name: text;
+   value: text;
+ };
+type Header = 
+ record {
+   text;
+   text;
+ };
+type FileId = text;
+type Err = text;
+type DownloadsSnapshot__1 = 
+ record {
+   downloads: nat;
+   endTime: Time;
+   startTime: Time;
+ };
+type DownloadsSnapshot = 
+ record {
+   downloads: nat;
+   endTime: Time;
+   startTime: Time;
+ };
+type DepsStatus = 
+ variant {
+   allLatest;
+   tooOld;
+   updatesAvailable;
+ };
+type DependencyV2 = 
+ record {
+   name: PackageName__1;
+   repo: text;
+   version: text;
+ };
+type DepChange = 
+ record {
+   name: text;
+   newVersion: text;
+   oldVersion: text;
+ };
+type Benchmarks__1 = vec Benchmark;
+type Benchmarks = vec Benchmark;
+type BenchmarkMetric = text;
+type Benchmark = 
+ record {
+   cols: vec text;
+   compiler: text;
+   compilerVersion: text;
+   description: text;
+   file: text;
+   forceGC: bool;
+   gc: text;
+   metrics: vec record {
+                  BenchmarkMetric;
+                  vec vec int;
+                };
+   name: text;
+   replica: text;
+   replicaVersion: text;
+   rows: vec text;
+ };
+service : () -> Main