app.ts

      obj.id = message.id;
    }
    if (message.email !== "") {
      obj.email = message.email;
    }
    if (message.password !== "") {
      obj.password = message.password;
    }
    return obj;
  },

  create(base?: DeepPartial<UserPatchRequest>): UserPatchRequest {
    return UserPatchRequest.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<UserPatchRequest>): UserPatchRequest {
    const message = createBaseUserPatchRequest();
    message.id = object.id ?? "";
    message.email = object.email ?? "";
    message.password = object.password ?? "";
    return message;
  },
};

function createBaseUser(): User {
  return { id: "", email: "", name: "" };
}

export const User = {
  encode(message: User, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    if (message.id !== "") {
      writer.uint32(10).string(message.id);
    }
    if (message.email !== "") {
      writer.uint32(18).string(message.email);
    }
    if (message.name !== "") {
      writer.uint32(26).string(message.name);
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): User {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseUser();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }

          message.id = reader.string();
          continue;
        case 2:
          if (tag !== 18) {
            break;
          }

          message.email = reader.string();
          continue;
        case 3:
          if (tag !== 26) {
            break;
          }

          message.name = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): User {
    return {
      id: isSet(object.id) ? globalThis.String(object.id) : "",
      email: isSet(object.email) ? globalThis.String(object.email) : "",
      name: isSet(object.name) ? globalThis.String(object.name) : "",
    };
  },

  toJSON(message: User): unknown {
    const obj: any = {};
    if (message.id !== "") {
      obj.id = message.id;
    }
    if (message.email !== "") {
      obj.email = message.email;
    }
    if (message.name !== "") {
      obj.name = message.name;
    }
    return obj;
  },

  create(base?: DeepPartial<User>): User {
    return User.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<User>): User {
    const message = createBaseUser();
    message.id = object.id ?? "";
    message.email = object.email ?? "";
    message.name = object.name ?? "";
    return message;
  },
};

function createBaseUsers(): Users {
  return { users: [] };
}

export const Users = {
  encode(message: Users, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
    for (const v of message.users) {
      User.encode(v!, writer.uint32(10).fork()).ldelim();
    }
    return writer;
  },

  decode(input: _m0.Reader | Uint8Array, length?: number): Users {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseUsers();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }

          message.users.push(User.decode(reader, reader.uint32()));
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },

  fromJSON(object: any): Users {
    return { users: globalThis.Array.isArray(object?.users) ? object.users.map((e: any) => User.fromJSON(e)) : [] };
  },

  toJSON(message: Users): unknown {
    const obj: any = {};
    if (message.users?.length) {
      obj.users = message.users.map((e) => User.toJSON(e));
    }
    return obj;
  },

  create(base?: DeepPartial<Users>): Users {
    return Users.fromPartial(base ?? {});
  },
  fromPartial(object: DeepPartial<Users>): Users {
    const message = createBaseUsers();
    message.users = object.users?.map((e) => User.fromPartial(e)) || [];
    return message;
  },
};

export type AppDefinition = typeof AppDefinition;
export const AppDefinition = {
  name: "App",
  fullName: "App",
  methods: {
    getProduct: {
      name: "GetProduct",
      requestType: ProductRequest,
      requestStream: false,
      responseType: Product,
      responseStream: false,
      options: {},
    },
    getRandomProduct: {
      name: "GetRandomProduct",
      requestType: EmptyRequest,
      requestStream: false,
      responseType: Product,
      responseStream: false,
      options: {},
    },
    getAllProducts: {
      name: "GetAllProducts",
      requestType: AllProductsRequest,
      requestStream: false,
      responseType: Products,
      responseStream: false,
      options: {},
    },
    getAllCategories: {
      name: "GetAllCategories",
      requestType: EmptyRequest,
      requestStream: false,
      responseType: Categories,
      responseStream: false,
      options: {},
    },
    getAllOrders: {
      name: "GetAllOrders",
      requestType: EmptyRequest,
      requestStream: false,
      responseType: Orders,
      responseStream: false,
      options: {},
    },
    getAllUserOrders: {
      name: "GetAllUserOrders",
      requestType: UserRequest,
      requestStream: false,
      responseType: Orders,
      responseStream: false,
      options: {},
    },
    getOrder: {
      name: "GetOrder",
      requestType: OrderRequest,
      requestStream: false,
      responseType: Order,
      responseStream: false,
      options: {},
    },
    getUser: {
      name: "GetUser",
      requestType: UserRequest,
      requestStream: false,
      responseType: User,
      responseStream: false,
      options: {},
    },
    getAllUsers: {
      name: "GetAllUsers",
      requestType: EmptyRequest,
      requestStream: false,
      responseType: Users,
      responseStream: false,
      options: {},
    },
    postOrder: {
      name: "PostOrder",
      requestType: Order,
      requestStream: false,
      responseType: Order,
      responseStream: false,
      options: {},
    },
    patchAccountDetails: {
      name: "PatchAccountDetails",
      requestType: UserPatchRequest,
      requestStream: false,
      responseType: User,
      responseStream: false,
      options: {},
    },
  },
} as const;

export interface AppServiceImplementation<CallContextExt = {}> {
  getProduct(request: ProductRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Product>>;
  getRandomProduct(request: EmptyRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Product>>;
  getAllProducts(request: AllProductsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Products>>;
  getAllCategories(request: EmptyRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Categories>>;
  getAllOrders(request: EmptyRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Orders>>;
  getAllUserOrders(request: UserRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Orders>>;
  getOrder(request: OrderRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Order>>;
  getUser(request: UserRequest, context: CallContext & CallContextExt): Promise<DeepPartial<User>>;
  getAllUsers(request: EmptyRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Users>>;
  postOrder(request: Order, context: CallContext & CallContextExt): Promise<DeepPartial<Order>>;
  patchAccountDetails(request: UserPatchRequest, context: CallContext & CallContextExt): Promise<DeepPartial<User>>;
}

export interface AppClient<CallOptionsExt = {}> {
  getProduct(request: DeepPartial<ProductRequest>, options?: CallOptions & CallOptionsExt): Promise<Product>;
  getRandomProduct(request: DeepPartial<EmptyRequest>, options?: CallOptions & CallOptionsExt): Promise<Product>;
  getAllProducts(request: DeepPartial<AllProductsRequest>, options?: CallOptions & CallOptionsExt): Promise<Products>;
  getAllCategories(request: DeepPartial<EmptyRequest>, options?: CallOptions & CallOptionsExt): Promise<Categories>;
  getAllOrders(request: DeepPartial<EmptyRequest>, options?: CallOptions & CallOptionsExt): Promise<Orders>;
  getAllUserOrders(request: DeepPartial<UserRequest>, options?: CallOptions & CallOptionsExt): Promise<Orders>;
  getOrder(request: DeepPartial<OrderRequest>, options?: CallOptions & CallOptionsExt): Promise<Order>;
  getUser(request: DeepPartial<UserRequest>, options?: CallOptions & CallOptionsExt): Promise<User>;
  getAllUsers(request: DeepPartial<EmptyRequest>, options?: CallOptions & CallOptionsExt): Promise<Users>;
  postOrder(request: DeepPartial<Order>, options?: CallOptions & CallOptionsExt): Promise<Order>;
  patchAccountDetails(request: DeepPartial<UserPatchRequest>, options?: CallOptions & CallOptionsExt): Promise<User>;
}

type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;

export type DeepPartial<T> = T extends Builtin ? T
  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
  : Partial<T>;

function longToNumber(long: Long): number {
  if (long.gt(globalThis.Number.MAX_SAFE_INTEGER)) {
    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
  }
  return long.toNumber();
}

if (_m0.util.Long !== Long) {
  _m0.util.Long = Long as any;
  _m0.configure();
}

function isSet(value: any): boolean {
  return value !== null && value !== undefined;
}