Python 2, 26 bytes

lambda(a,b),c:c/8*b+a[c%8]

Try it online!

The value (a,b) should be a list/tuple of 2:

[[-1,1,2,4,7,8,11,13],15] for Number
[[-3,3,6,9,12,18,21,24],30] for Fizz
[[-5,5,10,20,25,35,40,50],60] for Buzz
[[0,15,30,45,60,75,90,105],120] for FizzBuzz

Wonder if this violates this loophole as it's just a list. If it does, I will delete this answer.

Vyxal, 8 bytes

15ġ⁰=)ȯt

Try it Online!

Port of the other answers.

Perl 5 -p, 52 47 bytes

Saved 5 bytes thanks to @Dom Hastings.

/ /;$_=332312332132330x$';/(.*?$`){$'}/g;$_=pos

Try it online!

Where 0=FizzBuzz, 1=Buzz, 2=Fizz, 3=Number in the first of the two inputs. Finds the position of the n'th occurrence of what's wanted with a regexp search in a repeated 15 char string encoding number, fizz, buzz and fizzbuzz in their right places.

Husk, 8 bytes

!¥⁰m⌋15N

Try it online!

Input as 1=number, 3=Fizz, 5=Buzz, 15=FizzBuzz. Same approach as Lynn's comment to caird coinheringaahing's answer.

Alternative versions with successively less pre-processing squeezed into the values chosen as input:

12 bytes, with input as [0,0]=number, [1,0]=Fizz, [0,1]=Buzz & [1,1]=FizzBuzz.

!fo≡⁰§e¦3¦5N

Try it online!

The Husk congr command - ≡ - checks whether two lists have the same distribution of truthy/falsy elements: in this case, divisibility (¦) by 3 and 5.

or 14 bytes, finally with input just as 0=number, 1=Fizz, 2=Buzz & 3=FizzBuzz.

!¥mȯḋm¬§e%5%3N

Try it online!

Treats list of not-modulo (¬ & %) 3 or 5 as binary digits (ḋ).

R, 56 54 52 bytes

Edit: -4 bytes thanks to pajonk

function(n,i){while(n<-n-!(!T%%3)-i+2*!T%%5)T=T+1;T}

Try it online!

This really seems to have too many parentheses...
Edit: This is really pajonk's answer, now, after removing all the useless parentheses that I left in the original...

Desmos, 112 99 bytes

Input into the function \$f(n,k)\$, where \$n\$ is the number, and \$k\$ is the word.

Number = 0, Fizz = 3, Buzz = 5, FizzBuzz = 15

h(n)=floor(n)
a=mod(n-1,8)
f(n,k)=\{k=0:15h(n/8-1/8)+2a+h(2a/5+1)-h(a/3+2/3),k=15:kn,kn+kh(kn/15)\}

Try It On Desmos!

Try It On Desmos! - Prettified

Uses formula in OEIS A229829:

a(n) = 15*floor((n-1)/8) +2*f(n) +floor((2*f(n)+5)/5) -floor((f(n)+2)/3), where f(n) = (n-1) mod 8.

99.99% sure this could be golfed. Maybe I could shorten the OEIS formula somehow.

Python 2, 47 bytes

f=lambda n,c,k=1:n and-~f(n-(k**4%15==c),c,k+1)

Try it online!

Take in the category label c as:

Number -> 1
Fizz -> 6
Buzz -> 10
FizzBuzz -> 0

We fingerprint the category for k using k**4%15, which produces the corresponding value as listed above. This is wrapped in a recursive function for the n'th number meeting a condition.

Python 2, 54 bytes

lambda n,c:([n*7/8-3*~n/4%2,~-n/4,~-n/2,0][c/2%4]+n)*c

Try it online!

A short at writing direct formulas for each case, with input c as one of 1,3,5,15.

Charcoal, 22 bytes

Ｉ⊕§⌕Ａ×”{⊞‴¡*ＲX⭆eＲ”ＮＳ⊖θ

Try it online! Link is to verbose version of code. Takes the number as the first input and one of the letters F, B, Z or N as the second input. Explanation:

      ...       Compressed string `NNFNBFNNFBNFNNZ`
     ×          Repeated by
         Ｎ      First input as a number
   ⌕Ａ           Find all indices of
          Ｓ     Second input
  §             Indexed by
            θ   First input
           ⊖    Decremented
 ⊕              Incremented
Ｉ               Cast to string
                Implicitly print

Retina, 60 bytes

L$`^.
$'*$&¶$'*$(NNFNBFNNFBNFNNZ
L$`(.)+¶(?<-1>.*?\1)+
$.>%`

Try it online! Link includes test cases. Takes input as the letter F, B, Z or N followed by the number n. Explanation:

L$`^.

Match the letter. At this point, $' refers to the number n following it.

$'*$&¶$'*$(NNFNBFNNFBNFNNZ

Repeat the letter n times, then on the next line repeat the Fizz Buzz sequence 15n times.

L$`(.)+¶(?<-1>.*?\1)+

Match n copies of the letter on the first line, and use those to find the nth match of the letter on the second line.

$.>%`

Output the offset (.`) of the end (>) of the match relative to the start of the second line (%).

Python 2, 51 bytes

lambda d,n,k=0:n and-~f(d,n-(k%3/2*2+k%5/4==d),k+1)

Try it online!

-2 bytes thanks to AnttiP; becomes -4 using Python 2
-3 bytes thanks to ovs

0 for Number, 1 for Buzz, 2 for Fizz, 3 for FizzBuzz.

05AB1E (legacy), 9 bytes

µN53SÖ2βQ

First input is the \$number\$; second is a digit \$0\$ for Number, \$1\$ for Fizz, \$2\$ for Buzz, and \$3\$ for FizzBuzz.

Uses the legacy version of 05AB1E, because it'll implicitly output the index N after a while-loop µ. In the new 05AB1E version, an explicit trailing }N should be added to accomplish that.

Try it online or verify all test cases.

Explanation:

µ          # Loop until the counter_variable is equal to the first (implicit) input
 N         #  Push the loop-index
  53S      #  Push [5,3]
     Ö     #  Check if the loop-index is divisible by either 5 or 3
           #  (resulting in [0,0], [1,0], [0,1], or [1,1])
      2β   #  Convert it from a base-2 list to an integer
           #  ([0,0],[1,0],[0,1],[1,1] will become 0,1,2,3 respectively)
        Q  #  And check if it's equal to the second (implicit) input
           #  (if this is truthy: implicitly increase the counter_variable by 1)
           # (after the loop, the loop-index `N` is output implicitly)

05AB1E (legacy), 6 bytes

µN15¿Q

First input is the \$number\$; second is an integer \$1\$ for Number, \$3\$ for Fizz, \$5\$ for Buzz, and \$15\$ for FizzBuzz.

Port of @Lynn's Jelly comment (I now also notice my original program above uses a similar approach as @cairdCoinheringaahing's 10-bytes Jelly program, even though we came up with it independently. Not too surprising, since it's a pretty straight-forward approach.)

Try it online or verify all test cases.

Explanation:

µ       # Loop until the counter_variable is equal to the first (implicit) input
 N      #  Push the loop-index
  15¿   #  Get the GCD (Greatest Common Divisor) of this index and 15
     Q  #  And check if it's equal to the second (implicit) input
        #  (if this is truthy: implicitly increase the counter_variable by 1)
        # (after the loop, the loop-index `N` is output implicitly)

Python 2, 77 bytes

0 for Number, 1 for Buzz, 2 for Fizz, 3 for FizzBuzz. The formula for Number is taken from A229829.

t,n=input()
g=n-1
print[g/8*15+g%8*12/5+1+g%8/-3,(n+g/4)*3,(n+g/2)*5,n*15][t]

Try it online!

JavaScript (ES6), 44 bytes

Expects (s)(n) with s=0 for Number, s=1 for Fizz, s=2 for Buzz and s=3 for FizzBuzz.

(s,k=0)=>g=n=>n?g(n-=s==!(++k%3)+2*!(k%5)):k

Try it online!

Cheaty version, 35 bytes

Expects 4680 for Fizz, 1056 for Buzz, 1 for FizzBuzz and 27030 for Number.

(s,k=0)=>g=n=>n?g(n-=s>>++k%15&1):k

Try it online!

Jelly, 10 bytes

³3,5ḍḄ⁼ʋ#Ṫ

Try it online!

This uses 0 = Number, 1 = Buzz, 2 = Fizz and 3 = FizzBuzz

Jelly, 8 bytes

1g15=ɗ#Ṫ

Try it online!

Thanks to Lynn. This uses 1 = Number, 3 = Fizz, 5 = Buzz, 15 = FizzBuzz. Included separately as the numbers could encode extra data

How they work

³3,5ḍḄ⁼ʋ#Ṫ - Main link. Takes W=0,1,2,3 on the left, n on the right
       ʋ   - Last 4 links as a dyad f(k, W):
 3,5ḍ      -   Divisible by 3 or 5? Yields [0,0], [0,1], [1,0], [1,1]
     Ḅ     -   From binary; Yields 0, 1, 2, 3
      ⁼    -   Equals W?
³       #Ṫ - Starting from W, count up k = W, W+1, ..., returning the nth integer such that f(k, W) is true

1g15=ɗ#Ṫ - Main link. Takes W=1,3,5,15 on the left, n on the right
     ɗ   - Last 3 links as a dyad f(k, W):
 g15     -   GCD(k, 15)
    =    -   Does that equal W?
1     #Ṫ - Count up k = 1, 2, ..., returning the nth integer such that f(k, W) is true