ic-mops 2.2.0 → 2.2.1

package/bundle/declarations/main/main.did.js

@@ -0,0 +1,406 @@
+export const idlFactory = ({ IDL }) => {
+  const PackageName = IDL.Text;
+  const Result_3 = IDL.Variant({ 'ok' : IDL.Null, 'err' : IDL.Text });
+  const PublishingId = IDL.Text;
+  const Err = IDL.Text;
+  const Result = IDL.Variant({ 'ok' : IDL.Null, 'err' : Err });
+  const Text = IDL.Text;
+  const PackageVersion = IDL.Text;
+  const PackageId = IDL.Text;
+  const Time = IDL.Int;
+  const DownloadsSnapshot = IDL.Record({
+    'startTime' : Time,
+    'endTime' : Time,
+    'downloads' : IDL.Nat,
+  });
+  const FileId = IDL.Text;
+  const Result_8 = IDL.Variant({
+    'ok' : IDL.Vec(IDL.Tuple(FileId, IDL.Vec(IDL.Nat8))),
+    'err' : Err,
+  });
+  const Result_7 = IDL.Variant({ 'ok' : IDL.Vec(FileId), 'err' : Err });
+  const SemverPart = IDL.Variant({
+    'major' : IDL.Null,
+    'minor' : IDL.Null,
+    'patch' : IDL.Null,
+  });
+  const Result_6 = IDL.Variant({
+    'ok' : IDL.Vec(IDL.Tuple(PackageName, PackageVersion)),
+    'err' : Err,
+  });
+  const Result_5 = IDL.Variant({ 'ok' : PackageVersion, 'err' : Err });
+  const User = IDL.Record({
+    'id' : IDL.Principal,
+    'emailVerified' : IDL.Bool,
+    'twitter' : IDL.Text,
+    'displayName' : IDL.Text,
+    'name' : IDL.Text,
+    'site' : IDL.Text,
+    'email' : IDL.Text,
+    'twitterVerified' : IDL.Bool,
+    'githubVerified' : IDL.Bool,
+    'github' : IDL.Text,
+  });
+  const DepsStatus = IDL.Variant({
+    'allLatest' : IDL.Null,
+    'tooOld' : IDL.Null,
+    'updatesAvailable' : IDL.Null,
+  });
+  const PackageQuality = IDL.Record({
+    'depsStatus' : DepsStatus,
+    'docsCoverage' : IDL.Float64,
+    'hasDescription' : IDL.Bool,
+    'hasKeywords' : IDL.Bool,
+    'hasLicense' : IDL.Bool,
+    'hasDocumentation' : IDL.Bool,
+    'hasTests' : IDL.Bool,
+    'hasRepository' : IDL.Bool,
+    'hasReleaseNotes' : IDL.Bool,
+  });
+  const Script = IDL.Record({ 'value' : IDL.Text, 'name' : IDL.Text });
+  const DependencyV2 = IDL.Record({
+    'name' : PackageName,
+    'repo' : IDL.Text,
+    'version' : IDL.Text,
+  });
+  const Requirement = IDL.Record({ 'value' : IDL.Text, 'name' : IDL.Text });
+  const PackageConfigV3 = IDL.Record({
+    'dfx' : IDL.Text,
+    'moc' : IDL.Text,
+    'scripts' : IDL.Vec(Script),
+    'baseDir' : IDL.Text,
+    'documentation' : IDL.Text,
+    'name' : PackageName,
+    'homepage' : IDL.Text,
+    'description' : IDL.Text,
+    'version' : IDL.Text,
+    'keywords' : IDL.Vec(IDL.Text),
+    'donation' : IDL.Text,
+    'devDependencies' : IDL.Vec(DependencyV2),
+    'repository' : IDL.Text,
+    'dependencies' : IDL.Vec(DependencyV2),
+    'requirements' : IDL.Vec(Requirement),
+    'license' : IDL.Text,
+    'readme' : IDL.Text,
+  });
+  const PackagePublication = IDL.Record({
+    'storage' : IDL.Principal,
+    'time' : Time,
+    'user' : IDL.Principal,
+  });
+  const PackageSummary = IDL.Record({
+    'ownerInfo' : User,
+    'owners' : IDL.Vec(User),
+    'maintainers' : IDL.Vec(User),
+    'owner' : IDL.Principal,
+    'depAlias' : IDL.Text,
+    'quality' : PackageQuality,
+    'publisher' : User,
+    'highestVersion' : PackageVersion,
+    'downloadsTotal' : IDL.Nat,
+    'downloadsInLast30Days' : IDL.Nat,
+    'downloadsInLast7Days' : IDL.Nat,
+    'config' : PackageConfigV3,
+    'publication' : PackagePublication,
+  });
+  const BenchmarkMetric = IDL.Text;
+  const Benchmark = IDL.Record({
+    'gc' : IDL.Text,
+    'metrics' : IDL.Vec(IDL.Tuple(BenchmarkMetric, IDL.Vec(IDL.Vec(IDL.Int)))),
+    'cols' : IDL.Vec(IDL.Text),
+    'file' : IDL.Text,
+    'name' : IDL.Text,
+    'rows' : IDL.Vec(IDL.Text),
+    'description' : IDL.Text,
+    'compilerVersion' : IDL.Text,
+    'compiler' : IDL.Text,
+    'replica' : IDL.Text,
+    'replicaVersion' : IDL.Text,
+    'forceGC' : IDL.Bool,
+  });
+  const Benchmarks = IDL.Vec(Benchmark);
+  const TestStats = IDL.Record({
+    'passedNames' : IDL.Vec(IDL.Text),
+    'passed' : IDL.Nat,
+  });
+  const PackageFileStatsPublic = IDL.Record({
+    'sourceFiles' : IDL.Nat,
+    'sourceSize' : IDL.Nat,
+  });
+  const TestsChanges = IDL.Record({
+    'addedNames' : IDL.Vec(IDL.Text),
+    'removedNames' : IDL.Vec(IDL.Text),
+  });
+  const DepChange = IDL.Record({
+    'oldVersion' : IDL.Text,
+    'name' : IDL.Text,
+    'newVersion' : IDL.Text,
+  });
+  const PackageChanges = IDL.Record({
+    'tests' : TestsChanges,
+    'deps' : IDL.Vec(DepChange),
+    'curBenchmarks' : Benchmarks,
+    'prevDocsCoverage' : IDL.Float64,
+    'prevBenchmarks' : Benchmarks,
+    'notes' : IDL.Text,
+    'curDocsCoverage' : IDL.Float64,
+    'devDeps' : IDL.Vec(DepChange),
+  });
+  const PackageSummaryWithChanges = IDL.Record({
+    'ownerInfo' : User,
+    'owners' : IDL.Vec(User),
+    'maintainers' : IDL.Vec(User),
+    'owner' : IDL.Principal,
+    'depAlias' : IDL.Text,
+    'quality' : PackageQuality,
+    'publisher' : User,
+    'highestVersion' : PackageVersion,
+    'downloadsTotal' : IDL.Nat,
+    'downloadsInLast30Days' : IDL.Nat,
+    'downloadsInLast7Days' : IDL.Nat,
+    'config' : PackageConfigV3,
+    'changes' : PackageChanges,
+    'publication' : PackagePublication,
+  });
+  const PackageDetails = IDL.Record({
+    'benchmarks' : Benchmarks,
+    'ownerInfo' : User,
+    'owners' : IDL.Vec(User),
+    'maintainers' : IDL.Vec(User),
+    'owner' : IDL.Principal,
+    'depAlias' : IDL.Text,
+    'deps' : IDL.Vec(PackageSummary),
+    'quality' : PackageQuality,
+    'publisher' : User,
+    'testStats' : TestStats,
+    'docsCoverage' : IDL.Float64,
+    'highestVersion' : PackageVersion,
+    'downloadsTotal' : IDL.Nat,
+    'downloadsInLast30Days' : IDL.Nat,
+    'dependentsCount' : IDL.Nat,
+    'downloadTrend' : IDL.Vec(DownloadsSnapshot),
+    'fileStats' : PackageFileStatsPublic,
+    'versionHistory' : IDL.Vec(PackageSummaryWithChanges),
+    'dependents' : IDL.Vec(PackageSummary),
+    'devDeps' : IDL.Vec(PackageSummary),
+    'downloadsInLast7Days' : IDL.Nat,
+    'config' : PackageConfigV3,
+    'changes' : PackageChanges,
+    'versions' : IDL.Vec(PackageVersion),
+    'publication' : PackagePublication,
+  });
+  const Result_4 = IDL.Variant({ 'ok' : PackageDetails, 'err' : Err });
+  const StorageId = IDL.Principal;
+  const StorageStats = IDL.Record({
+    'fileCount' : IDL.Nat,
+    'cyclesBalance' : IDL.Nat,
+    'memorySize' : IDL.Nat,
+  });
+  const Header = IDL.Tuple(IDL.Text, IDL.Text);
+  const Request = IDL.Record({
+    'url' : IDL.Text,
+    'method' : IDL.Text,
+    'body' : IDL.Vec(IDL.Nat8),
+    'headers' : IDL.Vec(Header),
+    'certificate_version' : IDL.Opt(IDL.Nat16),
+  });
+  const StreamingToken = IDL.Vec(IDL.Nat8);
+  const StreamingCallbackResponse = IDL.Record({
+    'token' : IDL.Opt(StreamingToken),
+    'body' : IDL.Vec(IDL.Nat8),
+  });
+  const StreamingCallback = IDL.Func(
+      [StreamingToken],
+      [IDL.Opt(StreamingCallbackResponse)],
+      ['query'],
+    );
+  const StreamingStrategy = IDL.Variant({
+    'Callback' : IDL.Record({
+      'token' : StreamingToken,
+      'callback' : StreamingCallback,
+    }),
+  });
+  const Response = IDL.Record({
+    'body' : IDL.Vec(IDL.Nat8),
+    'headers' : IDL.Vec(Header),
+    'upgrade' : IDL.Opt(IDL.Bool),
+    'streaming_strategy' : IDL.Opt(StreamingStrategy),
+    'status_code' : IDL.Nat16,
+  });
+  const PageCount = IDL.Nat;
+  const Result_2 = IDL.Variant({ 'ok' : FileId, 'err' : Err });
+  const PackageConfigV3_Publishing = IDL.Record({
+    'dfx' : IDL.Text,
+    'moc' : IDL.Text,
+    'scripts' : IDL.Vec(Script),
+    'baseDir' : IDL.Text,
+    'documentation' : IDL.Text,
+    'name' : PackageName,
+    'homepage' : IDL.Text,
+    'description' : IDL.Text,
+    'version' : IDL.Text,
+    'keywords' : IDL.Vec(IDL.Text),
+    'donation' : IDL.Text,
+    'devDependencies' : IDL.Vec(DependencyV2),
+    'repository' : IDL.Text,
+    'dependencies' : IDL.Vec(DependencyV2),
+    'requirements' : IDL.Opt(IDL.Vec(Requirement)),
+    'license' : IDL.Text,
+    'readme' : IDL.Text,
+  });
+  const Result_1 = IDL.Variant({ 'ok' : PublishingId, 'err' : Err });
+  const HttpHeader = IDL.Record({ 'value' : IDL.Text, 'name' : IDL.Text });
+  const HttpRequestResult = IDL.Record({
+    'status' : IDL.Nat,
+    'body' : IDL.Vec(IDL.Nat8),
+    'headers' : IDL.Vec(HttpHeader),
+  });
+  const TransformArg = IDL.Record({
+    'context' : IDL.Vec(IDL.Nat8),
+    'response' : HttpRequestResult,
+  });
+  const Main = IDL.Service({
+    'addMaintainer' : IDL.Func([PackageName, IDL.Principal], [Result_3], []),
+    'addOwner' : IDL.Func([PackageName, IDL.Principal], [Result_3], []),
+    'backup' : IDL.Func([], [], []),
+    'computeHashesForExistingFiles' : IDL.Func([], [], []),
+    'finishPublish' : IDL.Func([PublishingId], [Result], []),
+    'getApiVersion' : IDL.Func([], [Text], ['query']),
+    'getBackupCanisterId' : IDL.Func([], [IDL.Principal], ['query']),
+    'getDefaultPackages' : IDL.Func(
+        [IDL.Text],
+        [IDL.Vec(IDL.Tuple(PackageName, PackageVersion))],
+        ['query'],
+      ),
+    'getDownloadTrendByPackageId' : IDL.Func(
+        [PackageId],
+        [IDL.Vec(DownloadsSnapshot)],
+        ['query'],
+      ),
+    'getDownloadTrendByPackageName' : IDL.Func(
+        [PackageName],
+        [IDL.Vec(DownloadsSnapshot)],
+        ['query'],
+      ),
+    'getFileHashes' : IDL.Func([PackageName, PackageVersion], [Result_8], []),
+    'getFileHashesByPackageIds' : IDL.Func(
+        [IDL.Vec(PackageId)],
+        [
+          IDL.Vec(
+            IDL.Tuple(PackageId, IDL.Vec(IDL.Tuple(FileId, IDL.Vec(IDL.Nat8))))
+          ),
+        ],
+        [],
+      ),
+    'getFileHashesQuery' : IDL.Func(
+        [PackageName, PackageVersion],
+        [Result_8],
+        ['query'],
+      ),
+    'getFileIds' : IDL.Func(
+        [PackageName, PackageVersion],
+        [Result_7],
+        ['query'],
+      ),
+    'getHighestSemverBatch' : IDL.Func(
+        [IDL.Vec(IDL.Tuple(PackageName, PackageVersion, SemverPart))],
+        [Result_6],
+        ['query'],
+      ),
+    'getHighestVersion' : IDL.Func([PackageName], [Result_5], ['query']),
+    'getMostDownloadedPackages' : IDL.Func(
+        [],
+        [IDL.Vec(PackageSummary)],
+        ['query'],
+      ),
+    'getMostDownloadedPackagesIn7Days' : IDL.Func(
+        [],
+        [IDL.Vec(PackageSummary)],
+        ['query'],
+      ),
+    'getNewPackages' : IDL.Func([], [IDL.Vec(PackageSummary)], ['query']),
+    'getPackageDependents' : IDL.Func(
+        [PackageName, IDL.Nat, IDL.Nat],
+        [IDL.Vec(PackageSummary), IDL.Nat],
+        ['query'],
+      ),
+    'getPackageDetails' : IDL.Func(
+        [PackageName, PackageVersion],
+        [Result_4],
+        ['query'],
+      ),
+    'getPackageMaintainers' : IDL.Func(
+        [PackageName],
+        [IDL.Vec(IDL.Principal)],
+        ['query'],
+      ),
+    'getPackageOwners' : IDL.Func(
+        [PackageName],
+        [IDL.Vec(IDL.Principal)],
+        ['query'],
+      ),
+    'getPackageVersionHistory' : IDL.Func(
+        [PackageName],
+        [IDL.Vec(PackageSummaryWithChanges)],
+        ['query'],
+      ),
+    'getPackagesByCategory' : IDL.Func(
+        [],
+        [IDL.Vec(IDL.Tuple(IDL.Text, IDL.Vec(PackageSummary)))],
+        ['query'],
+      ),
+    'getRecentlyUpdatedPackages' : IDL.Func(
+        [],
+        [IDL.Vec(PackageSummaryWithChanges)],
+        ['query'],
+      ),
+    'getStoragesStats' : IDL.Func(
+        [],
+        [IDL.Vec(IDL.Tuple(StorageId, StorageStats))],
+        ['query'],
+      ),
+    'getTotalDownloads' : IDL.Func([], [IDL.Nat], ['query']),
+    'getTotalPackages' : IDL.Func([], [IDL.Nat], ['query']),
+    'getUser' : IDL.Func([IDL.Principal], [IDL.Opt(User)], ['query']),
+    'http_request' : IDL.Func([Request], [Response], ['query']),
+    'notifyInstall' : IDL.Func([PackageName, PackageVersion], [], ['oneway']),
+    'notifyInstalls' : IDL.Func(
+        [IDL.Vec(IDL.Tuple(PackageName, PackageVersion))],
+        [],
+        ['oneway'],
+      ),
+    'removeMaintainer' : IDL.Func([PackageName, IDL.Principal], [Result_3], []),
+    'removeOwner' : IDL.Func([PackageName, IDL.Principal], [Result_3], []),
+    'restore' : IDL.Func([IDL.Nat], [], []),
+    'search' : IDL.Func(
+        [Text, IDL.Opt(IDL.Nat), IDL.Opt(IDL.Nat)],
+        [IDL.Vec(PackageSummary), PageCount],
+        ['query'],
+      ),
+    'setStorageControllers' : IDL.Func([], [], []),
+    'setUserProp' : IDL.Func([IDL.Text, IDL.Text], [Result_3], []),
+    'startFileUpload' : IDL.Func(
+        [PublishingId, Text, IDL.Nat, IDL.Vec(IDL.Nat8)],
+        [Result_2],
+        [],
+      ),
+    'startPublish' : IDL.Func([PackageConfigV3_Publishing], [Result_1], []),
+    'takeSnapshotsIfNeeded' : IDL.Func([], [], []),
+    'transformRequest' : IDL.Func(
+        [TransformArg],
+        [HttpRequestResult],
+        ['query'],
+      ),
+    'uploadBenchmarks' : IDL.Func([PublishingId, Benchmarks], [Result], []),
+    'uploadDocsCoverage' : IDL.Func([PublishingId, IDL.Float64], [Result], []),
+    'uploadFileChunk' : IDL.Func(
+        [PublishingId, FileId, IDL.Nat, IDL.Vec(IDL.Nat8)],
+        [Result],
+        [],
+      ),
+    'uploadNotes' : IDL.Func([PublishingId, IDL.Text], [Result], []),
+    'uploadTestStats' : IDL.Func([PublishingId, TestStats], [Result], []),
+  });
+  return Main;
+};
+export const init = ({ IDL }) => { return []; };

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

@@ -0,0 +1,50 @@
+import type {
+  ActorSubclass,
+  HttpAgentOptions,
+  ActorConfig,
+  Agent,
+} from "@icp-sdk/core/agent";
+import type { Principal } from "@icp-sdk/core/principal";
+import type { IDL } from "@icp-sdk/core/candid";
+
+import { _SERVICE } from './storage.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 storage: ActorSubclass<_SERVICE>;

package/bundle/declarations/storage/index.js

@@ -0,0 +1,30 @@
+import { Actor, HttpAgent } from "@icp-sdk/core/agent";
+
+// Imports and re-exports candid interface
+import { idlFactory } from './storage.did.js';
+export { idlFactory } from './storage.did.js';
+
+/**
+ *
+ * @param {string | import("@icp-sdk/core/principal").Principal} canisterId Canister ID of Agent
+ * @param {{agentOptions?: import("@icp-sdk/core/agent").HttpAgentOptions; actorOptions?: import("@icp-sdk/core/agent").ActorConfig}} [options]
+ * @return {import("@icp-sdk/core/agent").ActorSubclass<import("./storage.did.js")._SERVICE>}
+ */
+ export const createActor = (canisterId, options) => {
+  const agent = new HttpAgent({ ...options?.agentOptions });
+
+  // Fetch root key for certificate validation during development
+  if(process.env.NODE_ENV !== "production") {
+    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/storage/storage.did

@@ -0,0 +1,46 @@
+type StorageStats =
+ record {
+   cyclesBalance: nat;
+   fileCount: nat;
+   memorySize: nat;
+ };
+type Storage =
+ service {
+   acceptCycles: () -> ();
+   deleteFile: (FileId) -> ();
+   downloadChunk: (FileId, nat) -> (Result_2) query;
+   finishUpload: (FileId) -> ();
+   getFileIdsRange: (nat, nat) -> (vec FileId) query;
+   getFileMeta: (FileId) -> (Result_1) query;
+   getStats: () -> (StorageStats) query;
+   startUpload: (FileMeta) -> (Result);
+   updateFileOwners: (FileId, vec principal) -> ();
+   uploadChunk: (FileId, nat, Chunk) -> ();
+ };
+type Result_2 =
+ variant {
+   err: Err;
+   ok: Chunk;
+ };
+type Result_1 =
+ variant {
+   err: Err;
+   ok: FileMeta;
+ };
+type Result =
+ variant {
+   err: Err;
+   ok;
+ };
+type FileMeta =
+ record {
+   chunkCount: nat;
+   id: FileId__1;
+   owners: vec principal;
+   path: text;
+ };
+type FileId__1 = text;
+type FileId = text;
+type Err = text;
+type Chunk = blob;
+service : () -> Storage

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

@@ -0,0 +1,40 @@
+import type { Principal } from '@icp-sdk/core/principal';
+import type { ActorMethod } from '@icp-sdk/core/agent';
+import type { IDL } from '@icp-sdk/core/candid';
+
+export type Chunk = Array<number>;
+export type Err = string;
+export type FileId = string;
+export type FileId__1 = string;
+export interface FileMeta {
+  'id' : FileId__1,
+  'owners' : Array<Principal>,
+  'path' : string,
+  'chunkCount' : bigint,
+}
+export type Result = { 'ok' : null } |
+  { 'err' : Err };
+export type Result_1 = { 'ok' : FileMeta } |
+  { 'err' : Err };
+export type Result_2 = { 'ok' : Chunk } |
+  { 'err' : Err };
+export interface Storage {
+  'acceptCycles' : ActorMethod<[], undefined>,
+  'deleteFile' : ActorMethod<[FileId], undefined>,
+  'downloadChunk' : ActorMethod<[FileId, bigint], Result_2>,
+  'finishUpload' : ActorMethod<[FileId], undefined>,
+  'getFileIdsRange' : ActorMethod<[bigint, bigint], Array<FileId>>,
+  'getFileMeta' : ActorMethod<[FileId], Result_1>,
+  'getStats' : ActorMethod<[], StorageStats>,
+  'startUpload' : ActorMethod<[FileMeta], Result>,
+  'updateFileOwners' : ActorMethod<[FileId, Array<Principal>], undefined>,
+  'uploadChunk' : ActorMethod<[FileId, bigint, Chunk], undefined>,
+}
+export interface StorageStats {
+  'fileCount' : bigint,
+  'cyclesBalance' : bigint,
+  'memorySize' : bigint,
+}
+export interface _SERVICE extends Storage {}
+export declare const idlFactory: IDL.InterfaceFactory;
+export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];

package/bundle/declarations/storage/storage.did.js

@@ -0,0 +1,38 @@
+export const idlFactory = ({ IDL }) => {
+  const FileId = IDL.Text;
+  const Chunk = IDL.Vec(IDL.Nat8);
+  const Err = IDL.Text;
+  const Result_2 = IDL.Variant({ 'ok' : Chunk, 'err' : Err });
+  const FileId__1 = IDL.Text;
+  const FileMeta = IDL.Record({
+    'id' : FileId__1,
+    'owners' : IDL.Vec(IDL.Principal),
+    'path' : IDL.Text,
+    'chunkCount' : IDL.Nat,
+  });
+  const Result_1 = IDL.Variant({ 'ok' : FileMeta, 'err' : Err });
+  const StorageStats = IDL.Record({
+    'fileCount' : IDL.Nat,
+    'cyclesBalance' : IDL.Nat,
+    'memorySize' : IDL.Nat,
+  });
+  const Result = IDL.Variant({ 'ok' : IDL.Null, 'err' : Err });
+  const Storage = IDL.Service({
+    'acceptCycles' : IDL.Func([], [], []),
+    'deleteFile' : IDL.Func([FileId], [], []),
+    'downloadChunk' : IDL.Func([FileId, IDL.Nat], [Result_2], ['query']),
+    'finishUpload' : IDL.Func([FileId], [], []),
+    'getFileIdsRange' : IDL.Func(
+        [IDL.Nat, IDL.Nat],
+        [IDL.Vec(FileId)],
+        ['query'],
+      ),
+    'getFileMeta' : IDL.Func([FileId], [Result_1], ['query']),
+    'getStats' : IDL.Func([], [StorageStats], ['query']),
+    'startUpload' : IDL.Func([FileMeta], [Result], []),
+    'updateFileOwners' : IDL.Func([FileId, IDL.Vec(IDL.Principal)], [], []),
+    'uploadChunk' : IDL.Func([FileId, IDL.Nat, Chunk], [], []),
+  });
+  return Storage;
+};
+export const init = ({ IDL }) => { return []; };