instill-sdk 0.0.1

package/dist/protogen-ts/vdp/pipeline/v1alpha/operator_definition.ts

@@ -0,0 +1,948 @@
+/* eslint-disable */
+import * as _m0 from "protobufjs/minimal";
+import { Struct } from "../../../google/protobuf/struct";
+import { View, viewFromJSON, viewToJSON } from "./common";
+
+export const protobufPackage = "vdp.pipeline.v1alpha";
+
+/** View enumerates the definition views */
+export interface Spec {
+  /** Spec operator specification */
+  componentSpecification:
+    | { [key: string]: any }
+    | undefined;
+  /** Spec openapi specification */
+  openapiSpecifications: { [key: string]: any } | undefined;
+}
+
+/** Operator represents the operator definition data model */
+export interface OperatorDefinition {
+  /**
+   * Operator resource name. It must have the format of
+   * "operator-definitions/*"
+   */
+  name: string;
+  /** Operator UUID */
+  uid: string;
+  /**
+   * Operator resource ID (the last segment of the
+   * resource name) used to construct the resource name. This conforms to
+   * RFC-1034, which restricts to letters, numbers, and hyphen, with the first
+   * character a letter, the last a letter or a number, and a 63 character
+   * maximum.
+   */
+  id: string;
+  /** Operator title */
+  title: string;
+  /** Operator documentation URL */
+  documentationUrl: string;
+  /** Operator icon */
+  icon: string;
+  /** Operator spec */
+  spec:
+    | Spec
+    | undefined;
+  /**
+   * Operator tombstone, i.e., if not set or false, the
+   * configuration is active, or otherwise, if true, this configuration is
+   * permanently off
+   */
+  tombstone: boolean;
+  /**
+   * Operator public flag, i.e., true if this operator
+   * definition is available to all workspaces
+   */
+  public: boolean;
+  /**
+   * Operator custom flag, i.e., whether this is a custom
+   * operator definition
+   */
+  custom: boolean;
+  /** Operator iconUrl */
+  iconUrl: string;
+}
+
+/**
+ * ListOperatorDefinitionsRequest represents a request to list
+ * OperatorDefinitions
+ */
+export interface ListOperatorDefinitionsRequest {
+  /**
+   * The maximum number of OperatorDefinitions to return. The
+   * service may return fewer than this value. If unspecified, at most 10
+   * OperatorDefinitions will be returned. The maximum value is 100;
+   * values above 100 will be coerced to 100.
+   */
+  pageSize?:
+    | number
+    | undefined;
+  /** Page token */
+  pageToken?:
+    | string
+    | undefined;
+  /** Definition view (default is DEFINITION_VIEW_BASIC) */
+  view?:
+    | View
+    | undefined;
+  /** Filter expression to list operator definitions */
+  filter?: string | undefined;
+}
+
+/**
+ * ListOperatorDefinitionsResponse represents a response for a list
+ * of OperatorDefinitions
+ */
+export interface ListOperatorDefinitionsResponse {
+  /** A list of Operator resources */
+  operatorDefinitions: OperatorDefinition[];
+  /** Next page token */
+  nextPageToken: string;
+  /** Total count of Operator resources */
+  totalSize: number;
+}
+
+/**
+ * GetOperatorDefinitionRequest represents a request to query a
+ * Operator resource
+ */
+export interface GetOperatorDefinitionRequest {
+  /**
+   * Operator resource name. It must have the format of
+   * "operator-definitions/*"
+   */
+  name: string;
+  /**
+   * Operator resource view (default is
+   * DEFINITION_VIEW_BASIC)
+   */
+  view?: View | undefined;
+}
+
+/**
+ * GetOperatorDefinitionResponse represents a
+ * Operator response
+ */
+export interface GetOperatorDefinitionResponse {
+  /** A Operator resource */
+  operatorDefinition: OperatorDefinition | undefined;
+}
+
+/**
+ * LookUpOperatorDefinitionAdminRequest represents a request to query a
+ * operatorDefinition via permalink by admin
+ */
+export interface LookUpOperatorDefinitionAdminRequest {
+  /**
+   * Permalink of a operator. For example:
+   * "operator-definitions/{uid}"
+   */
+  permalink: string;
+  /** Operator view (default is VIEW_BASIC) */
+  view?: View | undefined;
+}
+
+/**
+ * LookUpOperatorAdminResponse represents a response for a
+ * operator
+ */
+export interface LookUpOperatorDefinitionAdminResponse {
+  /** operator resource */
+  operatorDefinition: OperatorDefinition | undefined;
+}
+
+function createBaseSpec(): Spec {
+  return { componentSpecification: undefined, openapiSpecifications: undefined };
+}
+
+export const Spec = {
+  encode(message: Spec, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.componentSpecification !== undefined) {
+      Struct.encode(Struct.wrap(message.componentSpecification), writer.uint32(10).fork()).ldelim();
+    }
+    if (message.openapiSpecifications !== undefined) {
+      Struct.encode(Struct.wrap(message.openapiSpecifications), writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Spec {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSpec();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.componentSpecification = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.openapiSpecifications = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Spec {
+    return {
+      componentSpecification: isObject(object.componentSpecification) ? object.componentSpecification : undefined,
+      openapiSpecifications: isObject(object.openapiSpecifications) ? object.openapiSpecifications : undefined,
+    };
+  },
+
+  toJSON(message: Spec): unknown {
+    const obj: any = {};
+    if (message.componentSpecification !== undefined) {
+      obj.componentSpecification = message.componentSpecification;
+    }
+    if (message.openapiSpecifications !== undefined) {
+      obj.openapiSpecifications = message.openapiSpecifications;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<Spec>, I>>(base?: I): Spec {
+    return Spec.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<Spec>, I>>(object: I): Spec {
+    const message = createBaseSpec();
+    message.componentSpecification = object.componentSpecification ?? undefined;
+    message.openapiSpecifications = object.openapiSpecifications ?? undefined;
+    return message;
+  },
+};
+
+function createBaseOperatorDefinition(): OperatorDefinition {
+  return {
+    name: "",
+    uid: "",
+    id: "",
+    title: "",
+    documentationUrl: "",
+    icon: "",
+    spec: undefined,
+    tombstone: false,
+    public: false,
+    custom: false,
+    iconUrl: "",
+  };
+}
+
+export const OperatorDefinition = {
+  encode(message: OperatorDefinition, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    if (message.uid !== "") {
+      writer.uint32(18).string(message.uid);
+    }
+    if (message.id !== "") {
+      writer.uint32(26).string(message.id);
+    }
+    if (message.title !== "") {
+      writer.uint32(34).string(message.title);
+    }
+    if (message.documentationUrl !== "") {
+      writer.uint32(42).string(message.documentationUrl);
+    }
+    if (message.icon !== "") {
+      writer.uint32(50).string(message.icon);
+    }
+    if (message.spec !== undefined) {
+      Spec.encode(message.spec, writer.uint32(58).fork()).ldelim();
+    }
+    if (message.tombstone === true) {
+      writer.uint32(64).bool(message.tombstone);
+    }
+    if (message.public === true) {
+      writer.uint32(72).bool(message.public);
+    }
+    if (message.custom === true) {
+      writer.uint32(80).bool(message.custom);
+    }
+    if (message.iconUrl !== "") {
+      writer.uint32(90).string(message.iconUrl);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): OperatorDefinition {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOperatorDefinition();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.uid = reader.string();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.id = reader.string();
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.title = reader.string();
+          continue;
+        case 5:
+          if (tag !== 42) {
+            break;
+          }
+
+          message.documentationUrl = reader.string();
+          continue;
+        case 6:
+          if (tag !== 50) {
+            break;
+          }
+
+          message.icon = reader.string();
+          continue;
+        case 7:
+          if (tag !== 58) {
+            break;
+          }
+
+          message.spec = Spec.decode(reader, reader.uint32());
+          continue;
+        case 8:
+          if (tag !== 64) {
+            break;
+          }
+
+          message.tombstone = reader.bool();
+          continue;
+        case 9:
+          if (tag !== 72) {
+            break;
+          }
+
+          message.public = reader.bool();
+          continue;
+        case 10:
+          if (tag !== 80) {
+            break;
+          }
+
+          message.custom = reader.bool();
+          continue;
+        case 11:
+          if (tag !== 90) {
+            break;
+          }
+
+          message.iconUrl = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): OperatorDefinition {
+    return {
+      name: isSet(object.name) ? String(object.name) : "",
+      uid: isSet(object.uid) ? String(object.uid) : "",
+      id: isSet(object.id) ? String(object.id) : "",
+      title: isSet(object.title) ? String(object.title) : "",
+      documentationUrl: isSet(object.documentationUrl) ? String(object.documentationUrl) : "",
+      icon: isSet(object.icon) ? String(object.icon) : "",
+      spec: isSet(object.spec) ? Spec.fromJSON(object.spec) : undefined,
+      tombstone: isSet(object.tombstone) ? Boolean(object.tombstone) : false,
+      public: isSet(object.public) ? Boolean(object.public) : false,
+      custom: isSet(object.custom) ? Boolean(object.custom) : false,
+      iconUrl: isSet(object.iconUrl) ? String(object.iconUrl) : "",
+    };
+  },
+
+  toJSON(message: OperatorDefinition): unknown {
+    const obj: any = {};
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.uid !== "") {
+      obj.uid = message.uid;
+    }
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    if (message.title !== "") {
+      obj.title = message.title;
+    }
+    if (message.documentationUrl !== "") {
+      obj.documentationUrl = message.documentationUrl;
+    }
+    if (message.icon !== "") {
+      obj.icon = message.icon;
+    }
+    if (message.spec !== undefined) {
+      obj.spec = Spec.toJSON(message.spec);
+    }
+    if (message.tombstone === true) {
+      obj.tombstone = message.tombstone;
+    }
+    if (message.public === true) {
+      obj.public = message.public;
+    }
+    if (message.custom === true) {
+      obj.custom = message.custom;
+    }
+    if (message.iconUrl !== "") {
+      obj.iconUrl = message.iconUrl;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<OperatorDefinition>, I>>(base?: I): OperatorDefinition {
+    return OperatorDefinition.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<OperatorDefinition>, I>>(object: I): OperatorDefinition {
+    const message = createBaseOperatorDefinition();
+    message.name = object.name ?? "";
+    message.uid = object.uid ?? "";
+    message.id = object.id ?? "";
+    message.title = object.title ?? "";
+    message.documentationUrl = object.documentationUrl ?? "";
+    message.icon = object.icon ?? "";
+    message.spec = (object.spec !== undefined && object.spec !== null) ? Spec.fromPartial(object.spec) : undefined;
+    message.tombstone = object.tombstone ?? false;
+    message.public = object.public ?? false;
+    message.custom = object.custom ?? false;
+    message.iconUrl = object.iconUrl ?? "";
+    return message;
+  },
+};
+
+function createBaseListOperatorDefinitionsRequest(): ListOperatorDefinitionsRequest {
+  return { pageSize: undefined, pageToken: undefined, view: undefined, filter: undefined };
+}
+
+export const ListOperatorDefinitionsRequest = {
+  encode(message: ListOperatorDefinitionsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.pageSize !== undefined) {
+      writer.uint32(8).int32(message.pageSize);
+    }
+    if (message.pageToken !== undefined) {
+      writer.uint32(18).string(message.pageToken);
+    }
+    if (message.view !== undefined) {
+      writer.uint32(24).int32(message.view);
+    }
+    if (message.filter !== undefined) {
+      writer.uint32(34).string(message.filter);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ListOperatorDefinitionsRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListOperatorDefinitionsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 8) {
+            break;
+          }
+
+          message.pageSize = reader.int32();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.pageToken = reader.string();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.view = reader.int32() as any;
+          continue;
+        case 4:
+          if (tag !== 34) {
+            break;
+          }
+
+          message.filter = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ListOperatorDefinitionsRequest {
+    return {
+      pageSize: isSet(object.pageSize) ? Number(object.pageSize) : undefined,
+      pageToken: isSet(object.pageToken) ? String(object.pageToken) : undefined,
+      view: isSet(object.view) ? viewFromJSON(object.view) : undefined,
+      filter: isSet(object.filter) ? String(object.filter) : undefined,
+    };
+  },
+
+  toJSON(message: ListOperatorDefinitionsRequest): unknown {
+    const obj: any = {};
+    if (message.pageSize !== undefined) {
+      obj.pageSize = Math.round(message.pageSize);
+    }
+    if (message.pageToken !== undefined) {
+      obj.pageToken = message.pageToken;
+    }
+    if (message.view !== undefined) {
+      obj.view = viewToJSON(message.view);
+    }
+    if (message.filter !== undefined) {
+      obj.filter = message.filter;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ListOperatorDefinitionsRequest>, I>>(base?: I): ListOperatorDefinitionsRequest {
+    return ListOperatorDefinitionsRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ListOperatorDefinitionsRequest>, I>>(
+    object: I,
+  ): ListOperatorDefinitionsRequest {
+    const message = createBaseListOperatorDefinitionsRequest();
+    message.pageSize = object.pageSize ?? undefined;
+    message.pageToken = object.pageToken ?? undefined;
+    message.view = object.view ?? undefined;
+    message.filter = object.filter ?? undefined;
+    return message;
+  },
+};
+
+function createBaseListOperatorDefinitionsResponse(): ListOperatorDefinitionsResponse {
+  return { operatorDefinitions: [], nextPageToken: "", totalSize: 0 };
+}
+
+export const ListOperatorDefinitionsResponse = {
+  encode(message: ListOperatorDefinitionsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.operatorDefinitions) {
+      OperatorDefinition.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.nextPageToken !== "") {
+      writer.uint32(18).string(message.nextPageToken);
+    }
+    if (message.totalSize !== 0) {
+      writer.uint32(24).int32(message.totalSize);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): ListOperatorDefinitionsResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseListOperatorDefinitionsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.operatorDefinitions.push(OperatorDefinition.decode(reader, reader.uint32()));
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.nextPageToken = reader.string();
+          continue;
+        case 3:
+          if (tag !== 24) {
+            break;
+          }
+
+          message.totalSize = reader.int32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ListOperatorDefinitionsResponse {
+    return {
+      operatorDefinitions: Array.isArray(object?.operatorDefinitions)
+        ? object.operatorDefinitions.map((e: any) => OperatorDefinition.fromJSON(e))
+        : [],
+      nextPageToken: isSet(object.nextPageToken) ? String(object.nextPageToken) : "",
+      totalSize: isSet(object.totalSize) ? Number(object.totalSize) : 0,
+    };
+  },
+
+  toJSON(message: ListOperatorDefinitionsResponse): unknown {
+    const obj: any = {};
+    if (message.operatorDefinitions?.length) {
+      obj.operatorDefinitions = message.operatorDefinitions.map((e) => OperatorDefinition.toJSON(e));
+    }
+    if (message.nextPageToken !== "") {
+      obj.nextPageToken = message.nextPageToken;
+    }
+    if (message.totalSize !== 0) {
+      obj.totalSize = Math.round(message.totalSize);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ListOperatorDefinitionsResponse>, I>>(base?: I): ListOperatorDefinitionsResponse {
+    return ListOperatorDefinitionsResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ListOperatorDefinitionsResponse>, I>>(
+    object: I,
+  ): ListOperatorDefinitionsResponse {
+    const message = createBaseListOperatorDefinitionsResponse();
+    message.operatorDefinitions = object.operatorDefinitions?.map((e) => OperatorDefinition.fromPartial(e)) || [];
+    message.nextPageToken = object.nextPageToken ?? "";
+    message.totalSize = object.totalSize ?? 0;
+    return message;
+  },
+};
+
+function createBaseGetOperatorDefinitionRequest(): GetOperatorDefinitionRequest {
+  return { name: "", view: undefined };
+}
+
+export const GetOperatorDefinitionRequest = {
+  encode(message: GetOperatorDefinitionRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    if (message.view !== undefined) {
+      writer.uint32(16).int32(message.view);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GetOperatorDefinitionRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetOperatorDefinitionRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.view = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetOperatorDefinitionRequest {
+    return {
+      name: isSet(object.name) ? String(object.name) : "",
+      view: isSet(object.view) ? viewFromJSON(object.view) : undefined,
+    };
+  },
+
+  toJSON(message: GetOperatorDefinitionRequest): unknown {
+    const obj: any = {};
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.view !== undefined) {
+      obj.view = viewToJSON(message.view);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetOperatorDefinitionRequest>, I>>(base?: I): GetOperatorDefinitionRequest {
+    return GetOperatorDefinitionRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetOperatorDefinitionRequest>, I>>(object: I): GetOperatorDefinitionRequest {
+    const message = createBaseGetOperatorDefinitionRequest();
+    message.name = object.name ?? "";
+    message.view = object.view ?? undefined;
+    return message;
+  },
+};
+
+function createBaseGetOperatorDefinitionResponse(): GetOperatorDefinitionResponse {
+  return { operatorDefinition: undefined };
+}
+
+export const GetOperatorDefinitionResponse = {
+  encode(message: GetOperatorDefinitionResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.operatorDefinition !== undefined) {
+      OperatorDefinition.encode(message.operatorDefinition, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): GetOperatorDefinitionResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseGetOperatorDefinitionResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.operatorDefinition = OperatorDefinition.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): GetOperatorDefinitionResponse {
+    return {
+      operatorDefinition: isSet(object.operatorDefinition)
+        ? OperatorDefinition.fromJSON(object.operatorDefinition)
+        : undefined,
+    };
+  },
+
+  toJSON(message: GetOperatorDefinitionResponse): unknown {
+    const obj: any = {};
+    if (message.operatorDefinition !== undefined) {
+      obj.operatorDefinition = OperatorDefinition.toJSON(message.operatorDefinition);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<GetOperatorDefinitionResponse>, I>>(base?: I): GetOperatorDefinitionResponse {
+    return GetOperatorDefinitionResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<GetOperatorDefinitionResponse>, I>>(
+    object: I,
+  ): GetOperatorDefinitionResponse {
+    const message = createBaseGetOperatorDefinitionResponse();
+    message.operatorDefinition = (object.operatorDefinition !== undefined && object.operatorDefinition !== null)
+      ? OperatorDefinition.fromPartial(object.operatorDefinition)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseLookUpOperatorDefinitionAdminRequest(): LookUpOperatorDefinitionAdminRequest {
+  return { permalink: "", view: undefined };
+}
+
+export const LookUpOperatorDefinitionAdminRequest = {
+  encode(message: LookUpOperatorDefinitionAdminRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.permalink !== "") {
+      writer.uint32(10).string(message.permalink);
+    }
+    if (message.view !== undefined) {
+      writer.uint32(16).int32(message.view);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): LookUpOperatorDefinitionAdminRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLookUpOperatorDefinitionAdminRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.permalink = reader.string();
+          continue;
+        case 2:
+          if (tag !== 16) {
+            break;
+          }
+
+          message.view = reader.int32() as any;
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): LookUpOperatorDefinitionAdminRequest {
+    return {
+      permalink: isSet(object.permalink) ? String(object.permalink) : "",
+      view: isSet(object.view) ? viewFromJSON(object.view) : undefined,
+    };
+  },
+
+  toJSON(message: LookUpOperatorDefinitionAdminRequest): unknown {
+    const obj: any = {};
+    if (message.permalink !== "") {
+      obj.permalink = message.permalink;
+    }
+    if (message.view !== undefined) {
+      obj.view = viewToJSON(message.view);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<LookUpOperatorDefinitionAdminRequest>, I>>(
+    base?: I,
+  ): LookUpOperatorDefinitionAdminRequest {
+    return LookUpOperatorDefinitionAdminRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<LookUpOperatorDefinitionAdminRequest>, I>>(
+    object: I,
+  ): LookUpOperatorDefinitionAdminRequest {
+    const message = createBaseLookUpOperatorDefinitionAdminRequest();
+    message.permalink = object.permalink ?? "";
+    message.view = object.view ?? undefined;
+    return message;
+  },
+};
+
+function createBaseLookUpOperatorDefinitionAdminResponse(): LookUpOperatorDefinitionAdminResponse {
+  return { operatorDefinition: undefined };
+}
+
+export const LookUpOperatorDefinitionAdminResponse = {
+  encode(message: LookUpOperatorDefinitionAdminResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.operatorDefinition !== undefined) {
+      OperatorDefinition.encode(message.operatorDefinition, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): LookUpOperatorDefinitionAdminResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseLookUpOperatorDefinitionAdminResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.operatorDefinition = OperatorDefinition.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): LookUpOperatorDefinitionAdminResponse {
+    return {
+      operatorDefinition: isSet(object.operatorDefinition)
+        ? OperatorDefinition.fromJSON(object.operatorDefinition)
+        : undefined,
+    };
+  },
+
+  toJSON(message: LookUpOperatorDefinitionAdminResponse): unknown {
+    const obj: any = {};
+    if (message.operatorDefinition !== undefined) {
+      obj.operatorDefinition = OperatorDefinition.toJSON(message.operatorDefinition);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<LookUpOperatorDefinitionAdminResponse>, I>>(
+    base?: I,
+  ): LookUpOperatorDefinitionAdminResponse {
+    return LookUpOperatorDefinitionAdminResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<LookUpOperatorDefinitionAdminResponse>, I>>(
+    object: I,
+  ): LookUpOperatorDefinitionAdminResponse {
+    const message = createBaseLookUpOperatorDefinitionAdminResponse();
+    message.operatorDefinition = (object.operatorDefinition !== undefined && object.operatorDefinition !== null)
+      ? OperatorDefinition.fromPartial(object.operatorDefinition)
+      : undefined;
+    return message;
+  },
+};
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function isObject(value: any): boolean {
+  return typeof value === "object" && value !== null;
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}