►
From YouTube: AsyncAPI spec 3.0 meeting
Description
B
To
make
sure
so
today,
I'm
soloing
this,
I
think,
unless
someone
is
listening,
everyone
is
apparently
on
holiday.
B
So
you
gotta
it's
just
me,
so
we
actually
don't
have
anything
for
the
agenda
today,
but
I
think
I
want
to
bring
up
in
not
an
issue,
but
something
we
discussed
a
few
times
now,
actually,
which
is
about
how
do
we
reference
non-json
data,
and
I
have
been
trying
to
deep
dive
a
bit
into
this
issue
because
it's
not
as
easy-
it's
not
as
easy
to
solve,
as
one
might
think,
mainly
because
there's
no
tooling
that
allows
for
this.
A
B
Magic
is
currently
working
on
this
proposal,
which,
in
short
kind
of
wraps
the
schema
format
that
allows
you
to
reference
or
not
reference,
but
to
inline
different
schema
types.
A
B
A
B
So
it's
just
a
little
bit
of
sugar
coating
in
a
sense,
but
this
is
the
standard
that
we
follow.
The
problem
is
that
this
standard
only
allows
json
value
to
reference
another
value
within
a
json
document
and
that's
a
problem.
If
you
try
to
reference
protobuf,
because
protobuf
is
not
json
value
now
you
can
make
some
hacks
to
make
it
works
tooling,
wise,
but
from
a
standard
perspective,
this.
A
B
B
There's
a
lot
of
different
issues
that
kind
of
relate
to
this,
or
touches
that
I
just
hit
a
little
and
I'm
not
entirely
sure
where
this
proposal
is
like
how
it
wraps
everything
together.
But
we
can
try
and
I'm
gonna
figure
that
one
out
later.
A
So
references
there's,
there's
kind
of
two
levels
to
this
there's
from.
A
A
B
Here
is
that
in
tooling,
whenever
it
finds
this
reference,
it
resolves
this
reference
based
on
this
standard.
It
has
this
resolution
part
which
defines
exactly
how
implementations
can
do
it
or
may
do
it.
For
example,
implementations
may
choose
to
replace
the
reference
with
the
reference
value
okay.
So
whenever
this
async
api
document,
let's
just
assume
it's
in
a
sick
api
document,
not
just
a
message,
it
means
that
it,
it
basically
resolves
and
replaces
the
reference
with
whatever
it
had
referenced.
A
A
B
Or
at
least
for
some
tooling
others
kind
of
need,
still
the
reference
keyword
and
or
at
least
that's
important
in
json
schema,
because
this
reference
keyword
is
validating
whatever
is
referenced,
and
this
gets
very
tricky
very
quickly.
So
I'm
just
going
to
skip
that.
So
the
point
is
that
when
we
reach
this
part,
it
means
that
we
all
of
the
sudden,
have
to
follow
a
new
standard
instead
of
the
one
that
we
defined
with
async
api,
and
we
cannot
get
around
this.
So
that's
just
a
fact:
it's
just
a
problem.
A
A
B
So
in
that
regard,
it's
it's
aligned
which
identifies
the
location
of
the
json
value
being
referenced
and.
A
B
B
The
comments
that
I
got
regarding
referencing
non-json
data
has
been
so
far
that
it
doesn't
make
much
sense
to
still
call
it
reference,
but
maybe
instead
contact
it
linking
so
we
linked
to
an
external
resource,
and
I'm
kind
of
think-
and
this
is
just
thinking
out
loud,
because
I
have
no
specific
proposal.
Yet
it's
just
I'm
just
throwing
out
ideas,
and
hopefully
some
of
them.
A
B
A
B
If
we
have
to
create
tooling
to
support
this
behavior,
I
think
it
makes
sense
to
look
at
it
from
like,
take
a
step
back
from
async
api
and
try
and
look
at
okay.
So
we
are
referencing
and
linking
to
certain
and
following
specific
standards,
but
it's
different
based
on
whatever
specification
is
like
where
the
reference
is
located,
for
example,
if
it
finds.
If
we
have
to
create
a
tool
we
might
as
well
figure
out,
can
we
can?
B
A
A
B
So
it's
gonna
be
a
bit
tricky
to
talk
about
okay,
so
we
link
slash
reference,
something
at
least
in
a
broader
sense,
because
you
saw
that
I
had
issues
formulating
the
definition
of
it
there,
because
I
can't
say
referencing,
because
referencing
is
only
for
json
referencing
and
linking
is
only
for
external
non-data
or
non-json
data
referencing,
or
they
set
it
refrigerant.
A
B
B
Changes
relative
references
and
how
they
resolve,
for
example-
and
this
is
if
you
can
define
a
base
uri
in
json-
schema-
they
define
the
base
uri
based
on
this
id
property
in
the
async
api.
We
don't
have
it
so
this
is
technically
irrelevant
for
us,
for
now,
at
least,
but
in
open
api,
they
define
it
in
their
server
objects.
B
A
B
A
A
A
Respectfully
so
I'm
just
gonna.
A
I
think
they
have
defined
their
own,
their
own
standard
for
it,
but
they
are
still
using
this.
A
B
A
B
B
Yeah
so
they
are
no
longer
using
or
at
least
references,
this
json
reference
standard.
B
A
A
B
A
B
A
A
B
B
B
B
It's
basically
a
relative
reference,
because
it's
only
here
that
the
base
uri
yeah,
for
example,
here
where
we
can
change
how
how
references
our
result
of
relative
references
are
resolved.
B
So
we
have
to
somehow
get
the
quote:
the
fully
qualified
uri
for
it.
So,
instead
of
relative
references,
it's
basically
returns.
A
B
B
B
A
B
I'm
not
even
sure
if
this
is
possible,
but
I
I
think
it
is
so.
Let's
say
that
we
have
enums
and
this
standard,
like
I
don't.
I
haven't
encountered
that
there
is
a
standout
for
this,
so
I'm
just
I'm
just
saying
stuff
that
I'm
not
sure
we
can
do,
but
I'm
just
gonna
run
run
with
it.
So
let's
say
that
we
have
enums
and
we
have
name.
A
B
A
B
B
B
B
So
let's
just
forget
this
down
here,
so
replacing
all
or
one
reference
with
the
reference
value
is
replacing
this
link
with
this,
because
this
is
what
it's
linked
to
the
other
one
is
that
the
password
just
looks
at
this
link
and
resolves
it
and
have
it
in
in
memory
basically,
and
do
nothing
with
the
link,
it
can
even
say
okay,
so
I
have
some
extension
I
can
use
in
async
api
x,
passer
content.
Let's
say
it
places
it
within
this.
Instead,
whatever
we
might
agree
on.
B
So
that's
resolving
the
reference
value,
so
it
doesn't
necessarily
replace
it,
and
this
is
important
in
the
newer
json
schema
as
well,
because
in
the
newer
json
schema
versions.
Well,.
B
In
those
cases,
you
don't
want
to
replace
references
with
the
referenced
value,
because
you
might
end
up
a
you
might
end
up
replacing
what
is
already
there
and
there's
no
definition
for
this
like
how
that
should
be
solved.
So
instead
they
just
this
reference
is
whenever
it
is
resolved
within
tooling.
B
Replaces
it
like
so
how
I
understand
it,
at
least
because
this
means
that,
from
a
validation
point
of
view,
it
can
tooling
can
look
through
all
of
these
keywords
and
then
it
it's
hidden.
It
encounters
a
reference
and
then
it
can
validate
whatever
is
within
this
reference
and
then
keep
going
afterwards.