@junobuild/admin 0.0.2 → 0.0.4

package/dist/declarations/frontend/frontend.did.d.ts

@@ -0,0 +1,128 @@
+import type {ActorMethod} from '@dfinity/agent';
+import type {Principal} from '@dfinity/principal';
+
+export type BatchId = bigint;
+export type BatchOperationKind =
+  | {CreateAsset: CreateAssetArguments}
+  | {UnsetAssetContent: UnsetAssetContentArguments}
+  | {DeleteAsset: DeleteAssetArguments}
+  | {SetAssetContent: SetAssetContentArguments}
+  | {Clear: ClearArguments};
+export type ChunkId = bigint;
+export type ClearArguments = {};
+export interface CreateAssetArguments {
+  key: Key;
+  content_type: string;
+  headers: [] | [Array<HeaderField>];
+  max_age: [] | [bigint];
+}
+export interface DeleteAssetArguments {
+  key: Key;
+}
+export type HeaderField = [string, string];
+export interface HttpRequest {
+  url: string;
+  method: string;
+  body: Uint8Array;
+  headers: Array<HeaderField>;
+}
+export interface HttpResponse {
+  body: Uint8Array;
+  headers: Array<HeaderField>;
+  streaming_strategy: [] | [StreamingStrategy];
+  status_code: number;
+}
+export type Key = string;
+export interface SetAssetContentArguments {
+  key: Key;
+  sha256: [] | [Uint8Array];
+  chunk_ids: Array<ChunkId>;
+  content_encoding: string;
+}
+export interface StreamingCallbackHttpResponse {
+  token: [] | [StreamingCallbackToken];
+  body: Uint8Array;
+}
+export interface StreamingCallbackToken {
+  key: Key;
+  sha256: [] | [Uint8Array];
+  index: bigint;
+  content_encoding: string;
+}
+export type StreamingStrategy = {
+  Callback: {
+    token: StreamingCallbackToken;
+    callback: [Principal, string];
+  };
+};
+export type Time = bigint;
+export interface UnsetAssetContentArguments {
+  key: Key;
+  content_encoding: string;
+}
+export interface _SERVICE {
+  authorize: ActorMethod<[Principal], undefined>;
+  certified_tree: ActorMethod<[{}], {certificate: Uint8Array; tree: Uint8Array}>;
+  clear: ActorMethod<[ClearArguments], undefined>;
+  commit_batch: ActorMethod<
+    [{batch_id: BatchId; operations: Array<BatchOperationKind>}],
+    undefined
+  >;
+  create_asset: ActorMethod<[CreateAssetArguments], undefined>;
+  create_batch: ActorMethod<[{}], {batch_id: BatchId}>;
+  create_chunk: ActorMethod<[{content: Uint8Array; batch_id: BatchId}], {chunk_id: ChunkId}>;
+  delete_asset: ActorMethod<[DeleteAssetArguments], undefined>;
+  get: ActorMethod<
+    [{key: Key; accept_encodings: Array<string>}],
+    {
+      content: Uint8Array;
+      sha256: [] | [Uint8Array];
+      content_type: string;
+      content_encoding: string;
+      total_length: bigint;
+    }
+  >;
+  get_chunk: ActorMethod<
+    [
+      {
+        key: Key;
+        sha256: [] | [Uint8Array];
+        index: bigint;
+        content_encoding: string;
+      }
+    ],
+    {content: Uint8Array}
+  >;
+  http_request: ActorMethod<[HttpRequest], HttpResponse>;
+  http_request_streaming_callback: ActorMethod<
+    [StreamingCallbackToken],
+    [] | [StreamingCallbackHttpResponse]
+  >;
+  list: ActorMethod<
+    [{}],
+    Array<{
+      key: Key;
+      encodings: Array<{
+        modified: Time;
+        sha256: [] | [Uint8Array];
+        length: bigint;
+        content_encoding: string;
+      }>;
+      content_type: string;
+    }>
+  >;
+  set_asset_content: ActorMethod<[SetAssetContentArguments], undefined>;
+  store: ActorMethod<
+    [
+      {
+        key: Key;
+        content: Uint8Array;
+        sha256: [] | [Uint8Array];
+        content_type: string;
+        content_encoding: string;
+      }
+    ],
+    undefined
+  >;
+  unset_asset_content: ActorMethod<[UnsetAssetContentArguments], undefined>;
+}

package/dist/declarations/frontend/frontend.factory.did.js

@@ -0,0 +1,165 @@
+export const idlFactory = ({IDL}) => {
+  const ClearArguments = IDL.Record({});
+  const BatchId = IDL.Nat;
+  const Key = IDL.Text;
+  const HeaderField = IDL.Tuple(IDL.Text, IDL.Text);
+  const CreateAssetArguments = IDL.Record({
+    key: Key,
+    content_type: IDL.Text,
+    headers: IDL.Opt(IDL.Vec(HeaderField)),
+    max_age: IDL.Opt(IDL.Nat64)
+  });
+  const UnsetAssetContentArguments = IDL.Record({
+    key: Key,
+    content_encoding: IDL.Text
+  });
+  const DeleteAssetArguments = IDL.Record({key: Key});
+  const ChunkId = IDL.Nat;
+  const SetAssetContentArguments = IDL.Record({
+    key: Key,
+    sha256: IDL.Opt(IDL.Vec(IDL.Nat8)),
+    chunk_ids: IDL.Vec(ChunkId),
+    content_encoding: IDL.Text
+  });
+  const BatchOperationKind = IDL.Variant({
+    CreateAsset: CreateAssetArguments,
+    UnsetAssetContent: UnsetAssetContentArguments,
+    DeleteAsset: DeleteAssetArguments,
+    SetAssetContent: SetAssetContentArguments,
+    Clear: ClearArguments
+  });
+  const HttpRequest = IDL.Record({
+    url: IDL.Text,
+    method: IDL.Text,
+    body: IDL.Vec(IDL.Nat8),
+    headers: IDL.Vec(HeaderField)
+  });
+  const StreamingCallbackToken = IDL.Record({
+    key: Key,
+    sha256: IDL.Opt(IDL.Vec(IDL.Nat8)),
+    index: IDL.Nat,
+    content_encoding: IDL.Text
+  });
+  const StreamingCallbackHttpResponse = IDL.Record({
+    token: IDL.Opt(StreamingCallbackToken),
+    body: IDL.Vec(IDL.Nat8)
+  });
+  const StreamingStrategy = IDL.Variant({
+    Callback: IDL.Record({
+      token: StreamingCallbackToken,
+      callback: IDL.Func(
+        [StreamingCallbackToken],
+        [IDL.Opt(StreamingCallbackHttpResponse)],
+        ['query']
+      )
+    })
+  });
+  const HttpResponse = IDL.Record({
+    body: IDL.Vec(IDL.Nat8),
+    headers: IDL.Vec(HeaderField),
+    streaming_strategy: IDL.Opt(StreamingStrategy),
+    status_code: IDL.Nat16
+  });
+  const Time = IDL.Int;
+  return IDL.Service({
+    authorize: IDL.Func([IDL.Principal], [], []),
+    certified_tree: IDL.Func(
+      [IDL.Record({})],
+      [
+        IDL.Record({
+          certificate: IDL.Vec(IDL.Nat8),
+          tree: IDL.Vec(IDL.Nat8)
+        })
+      ],
+      ['query']
+    ),
+    clear: IDL.Func([ClearArguments], [], []),
+    commit_batch: IDL.Func(
+      [
+        IDL.Record({
+          batch_id: BatchId,
+          operations: IDL.Vec(BatchOperationKind)
+        })
+      ],
+      [],
+      []
+    ),
+    create_asset: IDL.Func([CreateAssetArguments], [], []),
+    create_batch: IDL.Func([IDL.Record({})], [IDL.Record({batch_id: BatchId})], []),
+    create_chunk: IDL.Func(
+      [IDL.Record({content: IDL.Vec(IDL.Nat8), batch_id: BatchId})],
+      [IDL.Record({chunk_id: ChunkId})],
+      []
+    ),
+    delete_asset: IDL.Func([DeleteAssetArguments], [], []),
+    get: IDL.Func(
+      [IDL.Record({key: Key, accept_encodings: IDL.Vec(IDL.Text)})],
+      [
+        IDL.Record({
+          content: IDL.Vec(IDL.Nat8),
+          sha256: IDL.Opt(IDL.Vec(IDL.Nat8)),
+          content_type: IDL.Text,
+          content_encoding: IDL.Text,
+          total_length: IDL.Nat
+        })
+      ],
+      ['query']
+    ),
+    get_chunk: IDL.Func(
+      [
+        IDL.Record({
+          key: Key,
+          sha256: IDL.Opt(IDL.Vec(IDL.Nat8)),
+          index: IDL.Nat,
+          content_encoding: IDL.Text
+        })
+      ],
+      [IDL.Record({content: IDL.Vec(IDL.Nat8)})],
+      ['query']
+    ),
+    http_request: IDL.Func([HttpRequest], [HttpResponse], ['query']),
+    http_request_streaming_callback: IDL.Func(
+      [StreamingCallbackToken],
+      [IDL.Opt(StreamingCallbackHttpResponse)],
+      ['query']
+    ),
+    list: IDL.Func(
+      [IDL.Record({})],
+      [
+        IDL.Vec(
+          IDL.Record({
+            key: Key,
+            encodings: IDL.Vec(
+              IDL.Record({
+                modified: Time,
+                sha256: IDL.Opt(IDL.Vec(IDL.Nat8)),
+                length: IDL.Nat,
+                content_encoding: IDL.Text
+              })
+            ),
+            content_type: IDL.Text
+          })
+        )
+      ],
+      ['query']
+    ),
+    set_asset_content: IDL.Func([SetAssetContentArguments], [], []),
+    store: IDL.Func(
+      [
+        IDL.Record({
+          key: Key,
+          content: IDL.Vec(IDL.Nat8),
+          sha256: IDL.Opt(IDL.Vec(IDL.Nat8)),
+          content_type: IDL.Text,
+          content_encoding: IDL.Text
+        })
+      ],
+      [],
+      []
+    ),
+    unset_asset_content: IDL.Func([UnsetAssetContentArguments], [], [])
+  });
+};
+export const init = ({IDL}) => {
+  return [];
+};

package/dist/declarations/frontend/index.d.ts

@@ -0,0 +1,45 @@
+import type {ActorConfig, ActorSubclass, Agent, HttpAgentOptions} from '@dfinity/agent';
+import type {IDL} from '@dfinity/candid';
+import type {Principal} from '@dfinity/principal';
+
+import {_SERVICE} from './frontend.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 frontend: ActorSubclass<_SERVICE>;

package/dist/declarations/frontend/index.js

@@ -0,0 +1,32 @@
+import {Actor, HttpAgent} from '@dfinity/agent';
+
+// Imports and re-exports candid interface
+import {idlFactory} from './frontend.did.js';
+export {idlFactory} from './frontend.did.js';
+
+// CANISTER_ID is replaced by webpack based on node environment
+
+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/dist/declarations/ic/ic.did

@@ -0,0 +1,82 @@
+type canister_id = principal;
+type user_id = principal;
+type wasm_module = blob;
+
+type canister_settings = record {
+  controllers : opt vec principal;
+  compute_allocation : opt nat;
+  memory_allocation : opt nat;
+  freezing_threshold : opt nat;
+};
+
+type definite_canister_settings = record {
+  controllers : vec principal;
+  compute_allocation : nat;
+  memory_allocation : nat;
+  freezing_threshold : nat;
+};
+
+type http_header = record { name: text; value: text };
+
+type http_response = record {
+  status: nat;
+  headers: vec http_header;
+  body: blob;
+};
+
+type http_request_error = variant {
+  no_consensus;
+  timeout;
+  bad_tls;
+  invalid_url;
+  transform_error;
+  dns_error;
+  unreachable;
+  conn_timeout;
+};
+
+service ic : {
+  create_canister : (record {
+    settings : opt canister_settings
+  }) -> (record {canister_id : canister_id});
+  update_settings : (record {
+    canister_id : principal;
+    settings : canister_settings
+  }) -> ();
+  install_code : (record {
+    mode : variant {install; reinstall; upgrade};
+    canister_id : canister_id;
+    wasm_module : wasm_module;
+    arg : blob;
+  }) -> ();
+  uninstall_code : (record {canister_id : canister_id}) -> ();
+  start_canister : (record {canister_id : canister_id}) -> ();
+  stop_canister : (record {canister_id : canister_id}) -> ();
+  canister_status : (record {canister_id : canister_id}) -> (record {
+      status : variant { running; stopping; stopped };
+      settings: definite_canister_settings;
+      module_hash: opt blob;
+      memory_size: nat;
+      cycles: nat;
+  });
+  delete_canister : (record {canister_id : canister_id}) -> ();
+  deposit_cycles : (record {canister_id : canister_id}) -> ();
+  raw_rand : () -> (blob);
+  http_request : (record {
+    url : text;
+    method : variant { get };
+    headers: vec http_header;
+    body : opt blob;
+    transform : opt variant {
+      function: func (http_response) -> (http_response) query
+    };
+  }) -> (variant { Ok : http_response; Err: opt http_request_error });
+
+  // provisional interfaces for the pre-ledger world
+  provisional_create_canister_with_cycles : (record {
+    amount: opt nat;
+    settings : opt canister_settings
+  }) -> (record {canister_id : canister_id});
+  provisional_top_up_canister :
+    (record { canister_id: canister_id; amount: nat }) -> ();
+}

package/dist/declarations/ic/ic.did.d.ts

@@ -0,0 +1,77 @@
+import type {Principal} from '@dfinity/principal';
+export type canister_id = Principal;
+export interface canister_settings {
+  freezing_threshold: [] | [bigint];
+  controllers: [] | [Array<Principal>];
+  memory_allocation: [] | [bigint];
+  compute_allocation: [] | [bigint];
+}
+export interface definite_canister_settings {
+  freezing_threshold: bigint;
+  controllers: Array<Principal>;
+  memory_allocation: bigint;
+  compute_allocation: bigint;
+}
+export interface http_header {
+  value: string;
+  name: string;
+}
+export type http_request_error =
+  | {dns_error: null}
+  | {no_consensus: null}
+  | {transform_error: null}
+  | {unreachable: null}
+  | {bad_tls: null}
+  | {conn_timeout: null}
+  | {invalid_url: null}
+  | {timeout: null};
+export interface http_response {
+  status: bigint;
+  body: Array<number>;
+  headers: Array<http_header>;
+}
+export type user_id = Principal;
+export type wasm_module = Array<number>;
+export interface _SERVICE {
+  canister_status: (arg_0: {canister_id: canister_id}) => Promise<{
+    status: {stopped: null} | {stopping: null} | {running: null};
+    memory_size: bigint;
+    cycles: bigint;
+    settings: definite_canister_settings;
+    module_hash: [] | [Array<number>];
+  }>;
+  create_canister: (arg_0: {
+    settings: [] | [canister_settings];
+  }) => Promise<{canister_id: canister_id}>;
+  delete_canister: (arg_0: {canister_id: canister_id}) => Promise<undefined>;
+  deposit_cycles: (arg_0: {canister_id: canister_id}) => Promise<undefined>;
+  http_request: (arg_0: {
+    url: string;
+    method: {get: null};
+    body: [] | [Array<number>];
+    transform: [] | [{function: [Principal, string]}];
+    headers: Array<http_header>;
+  }) => Promise<{Ok: http_response} | {Err: [] | [http_request_error]}>;
+  install_code: (arg_0: {
+    arg: Array<number>;
+    wasm_module: wasm_module;
+    mode: {reinstall: null} | {upgrade: null} | {install: null};
+    canister_id: canister_id;
+  }) => Promise<undefined>;
+  provisional_create_canister_with_cycles: (arg_0: {
+    settings: [] | [canister_settings];
+    amount: [] | [bigint];
+  }) => Promise<{canister_id: canister_id}>;
+  provisional_top_up_canister: (arg_0: {
+    canister_id: canister_id;
+    amount: bigint;
+  }) => Promise<undefined>;
+  raw_rand: () => Promise<Array<number>>;
+  start_canister: (arg_0: {canister_id: canister_id}) => Promise<undefined>;
+  stop_canister: (arg_0: {canister_id: canister_id}) => Promise<undefined>;
+  uninstall_code: (arg_0: {canister_id: canister_id}) => Promise<undefined>;
+  update_settings: (arg_0: {
+    canister_id: Principal;
+    settings: canister_settings;
+  }) => Promise<undefined>;
+}

package/dist/declarations/ic/ic.factory.did.js

@@ -0,0 +1,128 @@
+export const idlFactory = ({IDL}) => {
+  const canister_id = IDL.Principal;
+  const definite_canister_settings = IDL.Record({
+    freezing_threshold: IDL.Nat,
+    controllers: IDL.Vec(IDL.Principal),
+    memory_allocation: IDL.Nat,
+    compute_allocation: IDL.Nat
+  });
+  const canister_settings = IDL.Record({
+    freezing_threshold: IDL.Opt(IDL.Nat),
+    controllers: IDL.Opt(IDL.Vec(IDL.Principal)),
+    memory_allocation: IDL.Opt(IDL.Nat),
+    compute_allocation: IDL.Opt(IDL.Nat)
+  });
+  const http_header = IDL.Record({value: IDL.Text, name: IDL.Text});
+  const http_response = IDL.Record({
+    status: IDL.Nat,
+    body: IDL.Vec(IDL.Nat8),
+    headers: IDL.Vec(http_header)
+  });
+  const http_request_error = IDL.Variant({
+    dns_error: IDL.Null,
+    no_consensus: IDL.Null,
+    transform_error: IDL.Null,
+    unreachable: IDL.Null,
+    bad_tls: IDL.Null,
+    conn_timeout: IDL.Null,
+    invalid_url: IDL.Null,
+    timeout: IDL.Null
+  });
+  const wasm_module = IDL.Vec(IDL.Nat8);
+  return IDL.Service({
+    canister_status: IDL.Func(
+      [IDL.Record({canister_id: canister_id})],
+      [
+        IDL.Record({
+          status: IDL.Variant({
+            stopped: IDL.Null,
+            stopping: IDL.Null,
+            running: IDL.Null
+          }),
+          memory_size: IDL.Nat,
+          cycles: IDL.Nat,
+          settings: definite_canister_settings,
+          module_hash: IDL.Opt(IDL.Vec(IDL.Nat8))
+        })
+      ],
+      []
+    ),
+    create_canister: IDL.Func(
+      [IDL.Record({settings: IDL.Opt(canister_settings)})],
+      [IDL.Record({canister_id: canister_id})],
+      []
+    ),
+    delete_canister: IDL.Func([IDL.Record({canister_id: canister_id})], [], []),
+    deposit_cycles: IDL.Func([IDL.Record({canister_id: canister_id})], [], []),
+    http_request: IDL.Func(
+      [
+        IDL.Record({
+          url: IDL.Text,
+          method: IDL.Variant({get: IDL.Null}),
+          body: IDL.Opt(IDL.Vec(IDL.Nat8)),
+          transform: IDL.Opt(
+            IDL.Variant({
+              function: IDL.Func([http_response], [http_response], ['query'])
+            })
+          ),
+          headers: IDL.Vec(http_header)
+        })
+      ],
+      [
+        IDL.Variant({
+          Ok: http_response,
+          Err: IDL.Opt(http_request_error)
+        })
+      ],
+      []
+    ),
+    install_code: IDL.Func(
+      [
+        IDL.Record({
+          arg: IDL.Vec(IDL.Nat8),
+          wasm_module: wasm_module,
+          mode: IDL.Variant({
+            reinstall: IDL.Null,
+            upgrade: IDL.Null,
+            install: IDL.Null
+          }),
+          canister_id: canister_id
+        })
+      ],
+      [],
+      []
+    ),
+    provisional_create_canister_with_cycles: IDL.Func(
+      [
+        IDL.Record({
+          settings: IDL.Opt(canister_settings),
+          amount: IDL.Opt(IDL.Nat)
+        })
+      ],
+      [IDL.Record({canister_id: canister_id})],
+      []
+    ),
+    provisional_top_up_canister: IDL.Func(
+      [IDL.Record({canister_id: canister_id, amount: IDL.Nat})],
+      [],
+      []
+    ),
+    raw_rand: IDL.Func([], [IDL.Vec(IDL.Nat8)], []),
+    start_canister: IDL.Func([IDL.Record({canister_id: canister_id})], [], []),
+    stop_canister: IDL.Func([IDL.Record({canister_id: canister_id})], [], []),
+    uninstall_code: IDL.Func([IDL.Record({canister_id: canister_id})], [], []),
+    update_settings: IDL.Func(
+      [
+        IDL.Record({
+          canister_id: IDL.Principal,
+          settings: canister_settings
+        })
+      ],
+      [],
+      []
+    )
+  });
+};
+export const init = ({IDL}) => {
+  return [];
+};

package/dist/declarations/internet_identity/index.d.ts

@@ -0,0 +1,45 @@
+import type {ActorConfig, ActorSubclass, Agent, HttpAgentOptions} from '@dfinity/agent';
+import type {IDL} from '@dfinity/candid';
+import type {Principal} from '@dfinity/principal';
+
+import {_SERVICE} from './internet_identity.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 internet_identity: ActorSubclass<_SERVICE>;