@milaboratories/pl-client 2.4.10

package/src/helpers/poll.ts

@@ -0,0 +1,178 @@
+import { PlClient } from '../core/client';
+import {
+  createRetryState,
+  nextRetryStateOrError,
+  notEmpty,
+  RetryOptions
+} from '@milaboratories/ts-helpers';
+import {
+  FieldData,
+  FieldType,
+  isNotNullResourceId,
+  isNullResourceId,
+  ResourceData,
+  ResourceId,
+  resourceIdToString
+} from '../core/types';
+import { PlTransaction } from '../core/transaction';
+import * as tp from 'node:timers/promises';
+
+/** This error tells state assertion mechanism that required state is not yet ready */
+export class ContinuePolling extends Error {}
+
+export type PollFieldTraverseOps = {
+  expectedType?: FieldType;
+  /** Fail if error present along with the value, if value not present,
+   * but error do, exception will be thrown anyway. */
+  failOnError: boolean;
+  /** Traverse only if field report its value as final. */
+  onlyFinal: boolean;
+};
+
+const DefaultPollFieldTraverseOps: PollFieldTraverseOps = {
+  failOnError: true,
+  onlyFinal: false
+};
+
+export class PollResourceAccessor {
+  constructor(
+    public readonly tx: PollTxAccessor,
+    public readonly data: ResourceData,
+    public readonly path: string[]
+  ) {}
+
+  public final(): PollResourceAccessor {
+    if (!this.data.final) throw new ContinuePolling();
+    return this;
+  }
+
+  public async requireNoError(): Promise<PollResourceAccessor> {
+    if (isNullResourceId(this.data.error)) return this;
+    await this.tx.throwError(this.data.error, this.path);
+    // hmm... https://github.com/microsoft/TypeScript/issues/34955
+    return this;
+  }
+
+  public getFieldData(name: string, expectedType?: FieldType): FieldData {
+    const fieldData = this.data.fields.find((f) => f.name === name);
+
+    if (fieldData !== undefined) {
+      if (expectedType !== undefined && fieldData.type !== expectedType)
+        throw new Error(`Unexpected field type. Expected ${expectedType}, found ${fieldData.type}`);
+      return fieldData;
+    }
+
+    if (
+      ((expectedType === 'Input' || expectedType === 'Service') && this.data.inputsLocked) ||
+      (expectedType === 'Output' && this.data.outputsLocked)
+    )
+      throw new Error(
+        `Field "${name}" not found. Expected type: ${expectedType}, state: ${this.data}`
+      );
+
+    throw new ContinuePolling();
+  }
+
+  public async get(
+    name: string,
+    ops: Partial<PollFieldTraverseOps> = {}
+  ): Promise<PollResourceAccessor> {
+    const { expectedType, failOnError, onlyFinal } = { ...DefaultPollFieldTraverseOps, ...ops };
+    const path = [...this.path, name];
+
+    const fieldData = this.getFieldData(name, expectedType);
+    if (isNotNullResourceId(fieldData.error) && (failOnError || isNullResourceId(fieldData.value)))
+      await this.tx.throwError(fieldData.error, path);
+
+    if (isNullResourceId(fieldData.value)) throw new ContinuePolling();
+
+    return await this.tx.get(fieldData.value, failOnError, path);
+  }
+
+  public async getMulti(
+    ops: Partial<PollFieldTraverseOps>,
+    ...names: string[]
+  ): Promise<PollResourceAccessor[]> {
+    return await Promise.all(names.map((name) => this.get(name, ops)));
+  }
+
+  public async getMultiObj<Key extends string>(
+    ops: Partial<PollFieldTraverseOps>,
+    ...names: Key[]
+  ): Promise<Record<Key, PollResourceAccessor>> {
+    return Object.fromEntries(
+      await Promise.all(names.map(async (name) => [name, await this.get(name, ops)]))
+    );
+  }
+
+  public async getAllFinal(
+    ops: Partial<PollFieldTraverseOps> = {}
+  ): Promise<Record<string, PollResourceAccessor>> {
+    return await this.getMultiObj(
+      ops,
+      ...this.data.fields
+        .filter((f) => f.valueIsFinal || isNotNullResourceId(f.error))
+        .map((f) => f.name)
+    );
+  }
+
+  public async getKValue(key: string): Promise<string> {
+    const value = await this.tx.tx.getKValueStringIfExists(this.data.id, key);
+    if (value === undefined) throw new ContinuePolling();
+    return value;
+  }
+
+  public async getKValueObj<T>(key: string): Promise<T> {
+    return JSON.parse(await this.getKValue(key)) as T;
+  }
+}
+
+export class PollTxAccessor {
+  constructor(public readonly tx: PlTransaction) {}
+
+  public async get(
+    rid: ResourceId,
+    failOnError: boolean = true,
+    path: string[] = []
+  ): Promise<PollResourceAccessor> {
+    const data = await this.tx.getResourceData(rid, true);
+    const accessor = new PollResourceAccessor(this, data, [...path, resourceIdToString(rid)]);
+    if (failOnError) await accessor.requireNoError();
+    return accessor;
+  }
+
+  async throwError(error: ResourceId, path: string[] = []): Promise<never> {
+    const errorRes = await this.get(error);
+    let errorText = Buffer.from(notEmpty(errorRes.data.data)).toString();
+    throw new Error(`${path.join(' -> ')} = ${errorText}`);
+  }
+}
+
+export const DefaultPollingRetryOptions: RetryOptions = {
+  type: 'linearBackoff',
+  jitter: 0,
+  maxAttempts: 100,
+  backoffStep: 10,
+  initialDelay: 10
+};
+
+export async function poll<T>(
+  cl: PlClient,
+  cb: (tx: PollTxAccessor) => Promise<T>,
+  retryOptions: RetryOptions = DefaultPollingRetryOptions,
+  txName: string = 'polling'
+): Promise<T> {
+  let retryState = createRetryState(retryOptions);
+  while (true) {
+    try {
+      return await cl.withReadTx(txName, async (tx) => {
+        return await cb(new PollTxAccessor(tx));
+      });
+    } catch (e: any) {
+      // Rethrowing any error except the "not ready yet"
+      if (!(e instanceof ContinuePolling)) throw e;
+    }
+    await tp.setTimeout(retryState.nextDelay);
+    retryState = nextRetryStateOrError(retryState);
+  }
+}

package/src/helpers/rich_resource_types.test.ts

@@ -0,0 +1,22 @@
+// type TestType1 = string;
+// type TestType2 = string | number | { a: number };
+//
+// const RichType1 = richResourceType('RichType1', '1');
+//
+// type WithAnyRichType<T> = WithRichType<T, string>
+//
+// function withRichType<RT extends PlResourceType>(t2: TestType2, type: RT): WithRichType<TestType1, RT> {
+//   return '' as WithRichType<TestType1, RT>;
+// }
+//
+// function something<RT extends PlResourceType, TT extends  WithRichType<TestType1, RT>>(t2: TT): TT
+// // function something(t2: TestType1): TestType1
+// function something(t2: TestType1): TestType1 {
+//   return t2;
+// }
+
+test('simple test', () => {
+  // const t2 = '';
+  // const t2a = withRichType(t2, RichType1);
+  // const t2c = something(t2a);
+});

package/src/helpers/rich_resource_types.ts

@@ -0,0 +1,84 @@
+// import { ResourceType } from './types';
+//
+// //
+// // NOTE: This code is not used.
+// //       It shows a raw idea on how to implement typed Tx API
+// //
+//
+// export type AnyStructuralResourceKind = 'structural' | 'ephemeral' | 'singleton'
+// export type ResourceKind = AnyStructuralResourceKind | 'value';
+//
+// declare const __resource_type: unique symbol;
+// export type WithRichType<T, B extends ResourceType> = T & { [__resource_type]: B }
+//
+// export type Serde<V> = {
+//   ser: (obj: V) => Uint8Array
+//   des: (data: Uint8Array) => V
+// }
+//
+// export type RichResourceType<Kind extends ResourceKind,
+//   Name extends string, Version extends string, Value = never> =
+//   {
+//     kind: Kind,
+//     name: Name,
+//     version: Version,
+//     serde: Serde<Value>
+//   }
+//
+// export type AnyStructuralRichResourceType = RichResourceType<AnyStructuralResourceKind, string, string, unknown>
+//
+// const DummySerde: Serde<never> = {
+//   ser: (t) => {
+//     throw new Error();
+//   },
+//   des: (t) => {
+//     throw new Error();
+//   }
+// };
+//
+// const NoSerde = { serde: DummySerde };
+//
+// export function richStructuralType<
+//   Name extends string,
+//   Version extends string,
+//   Kind extends AnyStructuralResourceKind>(
+//   kind: Kind,
+//   name: Name,
+//   version: Version
+// ): RichResourceType<Kind, Name, Version> {
+//   return { kind, name, version, ...NoSerde };
+// }
+//
+// export function richValueType<
+//   Name extends string,
+//   Version extends string,
+//   Value>(
+//   name: Name,
+//   version: Version,
+//   serde: Serde<Value>
+// ): RichResourceType<'value', Name, Version, Value> {
+//   return { kind: 'value', name, version, serde };
+// }
+//
+// export type RichFieldType<
+//   Parent extends AnyStructuralRichResourceType,
+//   Name extends string,
+//   Ref extends AnyStructuralRichResourceType> =
+//   {
+//     parent: Parent,
+//     name: Name,
+//     referenced: Ref
+//   }
+//
+// export function richFieldType<
+//   Parent extends AnyStructuralRichResourceType,
+//   Name extends string,
+//   Ref extends AnyStructuralRichResourceType>(
+//   parent: Parent,
+//   name: Name,
+//   referenced: Ref
+// ): RichFieldType<Parent, Name, Ref> {
+//   return { parent, name, referenced };
+// }
+//
+// const BContextEnd = richStructuralType('structural', 'BContextEnd', '1');

package/src/helpers/smart_accessors.ts

@@ -0,0 +1,146 @@
+// import { FieldData, isNotNullResourceId, ResourceData, ResourceKind } from '../core/types';
+// import { AnyFieldRef, AnyResourceRef, PlTransaction, ResourceRef } from '../core/transaction';
+// import { notEmpty } from '../util/util';
+//
+// export type Serde<V> = {
+//   ser: (obj: V) => Uint8Array
+//   des: (data: Uint8Array) => V
+// }
+//
+// const DummySerde: Serde<never> = {
+//   ser: () => {
+//     throw new Error();
+//   },
+//   des: () => {
+//     throw new Error();
+//   }
+// };
+//
+// const NoSerde = { serde: DummySerde };
+//
+// export type StructuralSmartResourceKind = 'structural' | 'ephemeral'
+// export type SmartResourceKind = StructuralSmartResourceKind | 'value'
+//
+// export type SmartResourceType<Kind extends ResourceKind, Name extends string,
+//   Version extends string, Value = never> =
+//   {
+//     kind: Kind,
+//     smartKind: SmartResourceKind,
+//     name: Name,
+//     version: Version,
+//     serde: Serde<Value>
+//   }
+//
+// export type AnySmartResourceType = SmartResourceType<ResourceKind, string, string, unknown>
+// export type AnyStructuralSmartResourceType = SmartResourceType<'Structural', string, string, unknown>
+//
+// export type SmartFieldType<
+//   Parent extends AnyStructuralSmartResourceType,
+//   Ref extends AnyStructuralSmartResourceType> =
+//   {
+//     parent: Parent,
+//     name: string,
+//     referenced: Ref
+//   }
+//
+// export type AnySmartFieldType = SmartFieldType<AnyStructuralSmartResourceType, AnyStructuralSmartResourceType>;
+//
+// export function structuralValueSRT<Name extends string, Version extends string, Value>(
+//   smartKind: SmartResourceKind,
+//   name: Name,
+//   version: Version,
+//   serde: Serde<Value>
+// ): SmartResourceType<'Structural', Name, Version, Value> {
+//   return { kind: 'Structural', smartKind, name, version, serde };
+// }
+//
+// export function structuralSRT<Name extends string, Version extends string>(
+//   smartKind: SmartResourceKind,
+//   name: Name,
+//   version: Version
+// ): SmartResourceType<'Structural', Name, Version, never> {
+//   return { kind: 'Structural', smartKind, name, version, serde: DummySerde };
+// }
+//
+// export function valueSRT<Name extends string, Version extends string, Value>(
+//   name: Name,
+//   version: Version,
+//   serde: Serde<Value>
+// ): SmartResourceType<'Value', Name, Version, Value> {
+//   return { kind: 'Value', smartKind: 'value', name, version, serde };
+// }
+//
+// export function smartFields<
+//   Parent extends AnyStructuralSmartResourceType,
+//   Ref extends AnyStructuralSmartResourceType>(
+//   parent: Parent,
+//   name: string,
+//   referenced: Ref
+// ): SmartFieldType<Parent, Ref> {
+//   return { parent, name, referenced };
+// }
+//
+// export type GetValueType<ST extends AnySmartResourceType> =
+//   ST extends SmartResourceType<ResourceKind, string, string, infer X> ? X : never
+//
+// export type GetRef<SF extends AnySmartFieldType> =
+//   SF extends SmartFieldType<AnyStructuralSmartResourceType, infer X> ? X : never
+//
+// export type GetParent<SF extends AnySmartFieldType> =
+//   SF extends SmartFieldType<infer X, AnyStructuralSmartResourceType> ? X : never
+//
+// export class SmartStructuralResourceAccessor<ST extends AnyStructuralSmartResourceType> {
+//   constructor(public readonly type: ST,
+//               public readonly ref: AnyResourceRef,
+//               public readonly tx: PlTransaction) {
+//   }
+//
+//   private _resourceData?: Promise<ResourceData>;
+//
+//   public async getResourceData(): Promise<ResourceData> {
+//     if (this._resourceData === undefined)
+//       this._resourceData = this.tx.getResourceData(this.ref, true);
+//     return await this._resourceData;
+//   }
+//
+//   public async getValue(): Promise<GetValueType<ST>> {
+//     return this.type.serde.des(notEmpty((await this.getResourceData()).data)) as GetValueType<ST>;
+//   }
+//
+//   public getField<SF extends SmartFieldType<ST, AnyStructuralSmartResourceType>>(field: SF): Promise<GetValueType<ST>> {
+//     return new SmartFieldAccessor(field, { resourceId: this.ref, fieldName: field.name }, this.tx);
+//   }
+//
+// }
+//
+// export class SmartFieldAccessor<SF extends AnySmartFieldType> {
+//   constructor(public readonly descriptor: SF,
+//               public readonly ref: AnyFieldRef,
+//               public readonly tx: PlTransaction) {
+//   }
+//
+//   public parent(): SmartStructuralResourceAccessor<GetParent<SF>> {
+//     return new SmartStructuralResourceAccessor(
+//       this.descriptor.parent as GetParent<SF>,
+//       this.ref.resourceId, this.tx);
+//   }
+//
+//   private _fieldData?: Promise<FieldData>;
+//
+//   public async getFieldData(): Promise<FieldData> {
+//     if (this._fieldData === undefined)
+//       this._fieldData = this.tx.getField(this.ref);
+//     return await this._fieldData;
+//   }
+//
+//
+//   public async get(): SmartStructuralResourceAccessor<GetRef<SF>> {
+//     const fieldData = await this.getFieldData();
+//     if (isNotNullResourceId(fieldData.error))
+//       throw new Error('Error in field.');
+//     return new SmartStructuralResourceAccessor(
+//       this.descriptor.referenced as GetRef<SF>,
+//       fieldData.value,
+//       this.tx);
+//   }
+// }

package/src/helpers/state_helpers.ts

@@ -0,0 +1,5 @@
+import { FieldData, isNotNullResourceId } from '../core/types';
+
+export function fieldResolved(data: Pick<FieldData, 'value' | 'error'>) {
+  return isNotNullResourceId(data.error) || isNotNullResourceId(data.value);
+}

package/src/helpers/tx_helpers.ts

@@ -0,0 +1,24 @@
+import { PlTransaction } from '../core/transaction';
+import { FieldData, OptionalResourceId, isNotNullResourceId } from '../core/types';
+import { notEmpty } from '@milaboratories/ts-helpers';
+
+export interface ValErr {
+  valueId: OptionalResourceId;
+  errorId: OptionalResourceId;
+  error?: string;
+}
+
+export async function valErr(tx: PlTransaction, f: FieldData): Promise<ValErr> {
+  const result = {
+    valueId: f.value,
+    errorId: f.error,
+    error: ''
+  };
+
+  if (isNotNullResourceId(f.error)) {
+    const e = await tx.getResourceData(f.error, true);
+    result.error = JSON.parse(notEmpty(e.data).toString());
+  }
+
+  return result;
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+export * from './core/types';
+export * as Pl from './helpers/pl';
+export * from './core/config';
+export * from './core/client';
+export * from './core/driver';
+export * from './core/transaction';
+export * from './core/errors';
+export * from './core/default_client';
+export * from './core/unauth_client';
+export * from './core/auth';
+export * from './helpers/tx_helpers';
+export * from './helpers/poll';
+
+export * as TestHelpers from './test/test_config';

package/src/proto/github.com/googleapis/googleapis/google/rpc/status.ts

@@ -0,0 +1,125 @@
+// @generated by protobuf-ts 2.9.4 with parameter client_generic,optimize_speed,generate_dependencies,force_server_none
+// @generated from protobuf file "github.com/googleapis/googleapis/google/rpc/status.proto" (package "google.rpc", syntax proto3)
+// tslint:disable
+//
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { Any } from "../../../../../google/protobuf/any";
+/**
+ * The `Status` type defines a logical error model that is suitable for
+ * different programming environments, including REST APIs and RPC APIs. It is
+ * used by [gRPC](https://github.com/grpc). Each `Status` message contains
+ * three pieces of data: error code, error message, and error details.
+ *
+ * You can find out more about this error model and how to work with it in the
+ * [API Design Guide](https://cloud.google.com/apis/design/errors).
+ *
+ * @generated from protobuf message google.rpc.Status
+ */
+export interface Status {
+    /**
+     * The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code].
+     *
+     * @generated from protobuf field: int32 code = 1;
+     */
+    code: number;
+    /**
+     * A developer-facing error message, which should be in English. Any
+     * user-facing error message should be localized and sent in the
+     * [google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client.
+     *
+     * @generated from protobuf field: string message = 2;
+     */
+    message: string;
+    /**
+     * A list of messages that carry the error details.  There is a common set of
+     * message types for APIs to use.
+     *
+     * @generated from protobuf field: repeated google.protobuf.Any details = 3;
+     */
+    details: Any[];
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class Status$Type extends MessageType<Status> {
+    constructor() {
+        super("google.rpc.Status", [
+            { no: 1, name: "code", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 2, name: "message", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "details", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Any }
+        ]);
+    }
+    create(value?: PartialMessage<Status>): Status {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.code = 0;
+        message.message = "";
+        message.details = [];
+        if (value !== undefined)
+            reflectionMergePartial<Status>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Status): Status {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int32 code */ 1:
+                    message.code = reader.int32();
+                    break;
+                case /* string message */ 2:
+                    message.message = reader.string();
+                    break;
+                case /* repeated google.protobuf.Any details */ 3:
+                    message.details.push(Any.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: Status, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int32 code = 1; */
+        if (message.code !== 0)
+            writer.tag(1, WireType.Varint).int32(message.code);
+        /* string message = 2; */
+        if (message.message !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.message);
+        /* repeated google.protobuf.Any details = 3; */
+        for (let i = 0; i < message.details.length; i++)
+            Any.internalBinaryWrite(message.details[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message google.rpc.Status
+ */
+export const Status = new Status$Type();

package/src/proto/github.com/milaboratory/pl/controllers/shared/grpc/downloadapi/protocol.client.ts

@@ -0,0 +1,45 @@
+// @generated by protobuf-ts 2.9.4 with parameter client_generic,optimize_speed,generate_dependencies,force_server_none
+// @generated from protobuf file "github.com/milaboratory/pl/controllers/shared/grpc/downloadapi/protocol.proto" (package "MiLaboratories.Controller.Shared", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { Download } from "./protocol";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { DownloadAPI_GetDownloadURL_Response } from "./protocol";
+import type { DownloadAPI_GetDownloadURL_Request } from "./protocol";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ *
+ * Download provides access to any data, that can be downloaded via network.
+ *
+ *
+ * @generated from protobuf service MiLaboratories.Controller.Shared.Download
+ */
+export interface IDownloadClient {
+    /**
+     * @generated from protobuf rpc: GetDownloadURL(MiLaboratories.Controller.Shared.DownloadAPI.GetDownloadURL.Request) returns (MiLaboratories.Controller.Shared.DownloadAPI.GetDownloadURL.Response);
+     */
+    getDownloadURL(input: DownloadAPI_GetDownloadURL_Request, options?: RpcOptions): UnaryCall<DownloadAPI_GetDownloadURL_Request, DownloadAPI_GetDownloadURL_Response>;
+}
+/**
+ *
+ * Download provides access to any data, that can be downloaded via network.
+ *
+ *
+ * @generated from protobuf service MiLaboratories.Controller.Shared.Download
+ */
+export class DownloadClient implements IDownloadClient, ServiceInfo {
+    typeName = Download.typeName;
+    methods = Download.methods;
+    options = Download.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: GetDownloadURL(MiLaboratories.Controller.Shared.DownloadAPI.GetDownloadURL.Request) returns (MiLaboratories.Controller.Shared.DownloadAPI.GetDownloadURL.Response);
+     */
+    getDownloadURL(input: DownloadAPI_GetDownloadURL_Request, options?: RpcOptions): UnaryCall<DownloadAPI_GetDownloadURL_Request, DownloadAPI_GetDownloadURL_Response> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<DownloadAPI_GetDownloadURL_Request, DownloadAPI_GetDownloadURL_Response>("unary", this._transport, method, opt, input);
+    }
+}