►
Description
Presentation for the SharePoint PnP webcast around SharePoint asset provisioning when solution is taken into use. More details from following blog post - https://dev.office.com/blogs/provisioning-sharepoint-assets-for-your-spfx-solution
A
Welcome
everybody,
this
a
SharePoint
planners
and
practices
webcast,
and
this
time
we
can
talk
about
how
to
provision
ship
and
assets
from
your
SharePoint
framework
solution,
the
shipment
framework.
At
the
time
this
video
has
been
recorded
when
just
the
g8
pretty
recently
and
one
of
the
things
what
we
have
in
the
GA
version
of
the
SharePoint
framework
is
a
connecticut
ability
to
provision
assets
whenever
the
solution
buckets
is
being
installed
in
this
webcast.
A
We're
going
to
talk
about
that
as
one
of
the
options,
the
provision
SharePoint
assets
from
your
SharePoint
framework
solution
and
then
there's
few
an
alternative
options
as
well,
so
we
will
walk
through
individual
options
and
we
will
deep
dive
on
the
feature
framework
way
of
doing
the
deployment
or
asset
provisioning.
So
you
will
understand
the
advantages
and
disadvantages
of
all
of
this
individual
options.
My
name
is
Erin
and
I'm,
a
senior
program
manager
from
SharePoint
engineering
and
with
me
today,
as
the
person
asking
all
the
hard
questions
it's
Waldeck.
B
A
A
Good
before
we
actually
go
to
the
content
itself
under
the
demo
will
show
how
this
can
be
done
in
practice
and
just
briefly
explaining
what
a
sharepoint
Batterson
practices
so
SharePoint
Patterson
practices
is
a
open
source
community
driven
initiative
which
is
coordinated
by
the
SharePoint
engineering,
but
we
work
together
with
community
like
MVPs
and
non
MVPs
community
members
to
cater
to
come
up
with
code
samples
guidance
documentation.
We
have
community
calls.
A
We
have
case
studies,
the
the
concentration
versus
Lee
is
in
the
shipment
framework
shipment
add-ins
max
of
craft
and
office
365
API,
and
we
also
covers
the
for
shipment
on
premises.
So
as
an
example
to
SharePoint,
adding
model
guidance
is
absolutely
applicable
for
on-premises
as
well
in
the
future.
The
sharepoint
framework
as
well
aka,
Miss
SharePoint
PNP,
is
the
one
address
to
remember.
Now,
let's
go
back
on
the
today's
content
so
do
scenario.
A
What
we
want
to
actually
achieve
is
that
somebody
adds
a
client-side
web
part
on
a
SharePoint
site
and
the
concert
web
part
actually
has
a
dependency
on
a
list
with
a
content,
type
or
specific
fields.
So
how
do
you
get
that
list
provision?
That's
really
the
key
scenario,
so
the
client-side
web
parts
want,
in
certain
scenarios
quite
often
actually,
and
they
want
store
information
to
the
lists
inertia
at
one
side,
so
you
most
likely
want
a
pre
provision
donated
fields
and
content
types
and
list
instances
for
the
client-side
web
parts.
A
A
Good
now
we
kind
of
have
multiple
different
options
to
make
this
happen.
So
how
do
we
actually
provision
denie
that
fields,
content
types
and
lists
to
the
sites,
so
the
option
number
one,
the
option
number
one
is
a
feature
framework.
The
way
of
provisioning
this
and
sets
whenever
to
adding
or
a
SPF
exsolution
is
being
installed
on
the
site,
and
this
essentially
happens
in
a
way
that,
when
you're
creating
the
SPF
X
solution,
you
are
defining
or
defying
your
element.
A
Xml
files
and
optional
schema
XML
files
for
your
lists
to
be
deployed
or
included
as
part
of
your
SP
p
kk
package.
Essentially
the
solution
package
for
Chevron
framework
solution.
It
has
the
limited
set
of
feature
framework
elements
supported
and
we're
gonna
go
through
them
as
slightly
later
on
the
slides
as
well,
and
when
you're
actually
activating
the
solution,
you
do
not
have
to
be
and
site
owner
to
make
that
happen.
A
So
as
long
as
you
have
the
rights
to
add
an
app
or
a
tan
list,
so
to
say
to
the
site,
you
can
add
data
app
from
App
Catalog
to
the
site
and
then
the
provisioning
of
this
lists
and
fields
and
content
types
will
happen.
Using
kind
of
the
SharePoint
system
account,
obviously
the
challenge
of
this
one
is
that
this
does
require
deep
knowledge
of
SharePoint
internals
and
those
external
structures.
So,
and
it's
obviously,
is
it
deep
knowledge
or
is
it
one
to
one
on
xml
sides?
A
But
it's
you
need
to
understand
some
of
the
future
framework
and
element
xml
files
to
make
this
happen
now
the
feature
framework,
if
we
use
this
feature
framework
option
with
SharePoint
framework
solutions
that
does
support
elevation
and
what
that
means
is
that
you,
the
person
who's
installing
the
the
solution,
doesn't
have
to
be
an
administrator
within
a
site.
The
flexibility
is
limited,
because
we
only
have
a
subset
of
elements
being
supported
for
this
option
and
that
is
absolutely
currently
natively
available
within
a
SharePoint
Online.
A
Your
permissions
where
the
code
is
being
executed
is
the
current
user
permission,
and
this
is
essentially
the
challenge
with
this
option,
because
if
the
end
user
does
not
have
the
sufficient
permissions
who's
having
the
site
and
adding
the
client-side
web
part
on
the
site
or
the
solution
to
the
side
or
starts
using
the
web
part,
then
the
provision
of
those
assets
would
actually
fail.
And
then
you
need
to
deal
with
that
within
your
code.
A
A
For
that
particular
web
part.
Then,
on
the
next
time
somebody
is
using
the
web
part
web
per
disk
and
checking
hey
is
the
list
available?
Oh,
it
is
fine.
I,
don't
need
to
show
that
Adel
locking,
link
and
entered
called
my
external
web
service
to
challenge
the
bursa
with
this
one.
Is
that
it
it
does
require
a
lot
of
customizations,
so
there's
no
native
way
of
making
this
happen.
So,
first
of
all,
you
need
to
implement
that
custom
logic
within
the
client-side
web
port.
A
As
an
example,
where
you
check,
if
list
is
here,
then
you
serve
to
looking,
then
you
call
the
web
api
identity
to
implement
the
web
api
as
well,
which
is
which
can
use
up
only
to
call
back
on
the
sharepoint
and
apply
at
the
needed
settings.
So
there's
quite
a
lot
of
bits
and
pieces
in
this
options
and
the
complexity
no
doubt
increases
enormously.
On
the
other
hand,
the
flexibility
flexibility
is
unlimited
because
you
are
essentially
calling
stuff
outside
of
schipper
outside
of
sharepoint
online.
A
You
are
calling,
for
example,
I
share
with
API
and
the
web.
Api
can
then
take
advantage
of
whatever
we
have
in
usher
and
it
can
take
advantage
of
the
season
tenant
level,
a
B
as
it
can
do
whatever
needed
from
that
perspective.
Well,
why
would
you
need
to
use
the
tenant
api's
when
you're
using
your
hands
at
web
part
and
when
a
prohibitionist
okay?
Maybe
that's
not
that's
pretty
far-fetched
option,
but
anyway
it's
unlimited
flexibility
to
the
level
of
what
API
is.
Do
we
have
available
in
SharePoint
Online?
A
The
one
thing
to
call
out
with
this
one
is
that
the
currently
natively
available
option
on
this
one.
We
mark
that
within
a
yellow-orange
Canara
in
the
middle
area,
there
right
now
to
be
able
to
call
in
a
secure
way
a
web
api
which
is
hosted
in
inertia.
You
need
to
implement
that
a
dark
all
by
yourself
within
your
web
part
or
JavaScript,
which
are
using
in
SharePoint
Online
and
because
the
old
indications
scheme
in
SharePoint,
Online
and
usher
ad
is
slightly
different.
A
We
are
working
on
making
this
much
more
simplified
in
the
future,
so
in
in
the
shape
and
engineering
we're
working
on
making
sure
that
you
can
more
easily
call
also
third-party
web
api
Azure
services,
which
are
secured
by
your
assure
ad
today
and
we're
two
weeks
or
one
week
after
the
GA.
One
way.
Probably
time
flies,
I
can
track
the
date,
but
today
it's
still
relatively
limited,
but
this
will
be
changed
in
the
future
and
will
absolutely
do
a
podcast
whenever
the
new
changes
are
available
as
well.
B
Thing
that
I
wanted
to
ask
them.
It's
a
big
thing
right
for
quite
a
few
years
already.
I
think
yes,
three
years
or
more
you've
been
telling
us
that
we
should
move
away
from
the
clarity
of
provisioning
and
move
more
towards
remote
provisioning
and
then
SPF
XJS,
and
we
see
what
declarative
visioning.
What.
A
Was
that
yeah
absolutely
understandable
question?
So
whenever
you
are
provisioning,
let's
say
sites
or
site
level
operations,
as
in
the
old
school
way,
we
call
them
site
templates
or
site
definitions.
You
definitely
want
to
use
a
remote
provisioning
in
the
future
as
well,
and
we
do
have
awesome
community
treatment
tooling
for
that
one
from
a
PNP
as
an
example
and
other
many
other
remote
provisioning
frameworks
out
there.
But
this
is
more
around
the
initial
simplistic
way
of
enabling
one
list:
creation
or
list
creation
the
the
simplistic
list-
creation
for
a
client-side
web
poor.
A
So
what
we
wanted
to
do
within
the
or
what
we
decided
to
do
in
ship
on
the
engineering
side
was
that
hey
we
need
to.
We
need
to
solve
out
in
a
really
simplistic
way.
The
scenario
where
the
client-side
web
part
has
a
dependency
on
a
list.
It
requires
a
list.
It
requires
a
task
list.
It
requires
the
document
list
of
whatever
to
be
to
ektu.
It
exists
on
a
site
where
the
client-side
web
part
is
being
used
and
the
most
is
simplistic
way
to
solve.
A
That
was
really
to
to
take
advantage
of
the
existing
process
and
pipeline
what
we
had
related
on
Adams.
So
essentially,
what
the
model
is
doing
is
that
it's
taking
advantage
of
exactly
the
same
process
and
pipeline
which
we
used
for
adding
web,
but
we
actually
apply
the
settings
to
the
host
web
natively
because
the
adding
web
concept
doesn't
exist
in
the
SharePoint
framework,
so
really
the
feature
framework
when
installed
option,
it
is
limited
and
it's
it's
really
for
there
to
address
that
most
simplex.
A
B
With
that,
you
also
would
have
to
take
into
account
that
if
you
have
a
webpart
installed
in
a
site,
you
could
add
the
same
web
part
even
multiple
times
to
one
page
or
actually
it's
multiple
pages
in
the
site.
Correct,
whereas
with
XML
you'll
have
only
one
list
so
you'll
have.
You
would
have
to
take
into
account
that
that
list
will
be
shared
amongst
multiple
instances
of
the
same
web,
part
in
a
site
right.
That's.
A
A
fair
point,
but
to
be
fair,
that
same
option
does
the
or
chance
I
would
say
same
challenge
does
apply
across
all
of
these
options
because
it
doesn't
really
matter
how
do
you
get
to,
but
for
the
lists
created.
If
you
design
your
web
part
in
a
way
that
it
can
be
placed
in
multiple
pages
which
yeah
but
obviously
it
can,
you
need
to
consider
the
option.
How
do
you
filter
the
data
and
do
you
filter
that,
based
on
a
base
URL
in
the
list,
or
how
do
you
actually?
B
So
I
could
imagine
that
when
you
would
do
provisioning
in
code,
you
could
have
a
separate
list
created
for
every
instance
and
then
store
the
list
you're
good
with
the
web
part
and
that
tied
them
together
to
isolate
the
data
fair
for
the
web.
Part
in
simulus
right,
Adobe,
obviously
more
maintenance
more
effort
to
do
that,
but
that
would
be
an
option
that
you
could
choose
if
you
wanted
to.
A
No
doubt,
and
that
is
a
valid
option,
and
then
you
would
store.
Let's
say
that
in
the
web
part
properties
hey.
This
is
Janice
Twitter's
created
for
this
particular
web
part
instance,
and
then
you
would
have
a
native
filtering.
You
might
universe
case
scenario.
You
might
end
up
having
quite
a
few
lists
in
your
site
to
be
created.
If
you
have
multiple
pages
in
your
site,
but
again
it's
a
matter
of
a
choice.
This
is
not
a
black
and
white
and
black
and
white.
Let's
say
this
is
right.
This
is
wrong.
A
B
A
Whenever
I'm
moving
the
wet
part
or
the
solution
from
a
site,
because
the
wet
part
comes
available
and
visible
in
a
scythe
whenever
you
install
that
wet
part
to
the
site
at
the
site
level
and
that's
a
good
point
to
remember
its
site
level,
not
a
site
collection
level
installation.
So
whenever
you
add
the
wet
part
to
the
site,
we
provision
the
elements
and
that
would
be
applying
for
all
of
these
three
options.
A
Actually,
whenever
you
are
uninstalling
and
that
s
perfect
solution
before
the
site,
there
is
currently
no
Evans
being
raised
as
part
of
that,
so
there's
no
way
of
calling
an
external
set
of
services.
Hey
this
solution
has
been
uninstalled,
then
that
means
that
all
of
the
existing
data
which
was
created
to
the
site
used
in
the
client-side
web
part
would
still
remain
in
the
site
now
for
the
future.
Yes,
looking
like
that
is
good
too,
because
we're
not
deleting
anything
and
to
be
honest
when
I
think
about
it.
A
If
we
go
back
on
the
future
framework
timeframe
of
a
farm
solution
timeframe,
that
was
pretty
much
exactly
how
the
farm
solutions
worked.
We
never
actually
delay
that
lists.
We
never
actually
delay
that
content
type
if
they,
if
there
was
data
related
on
those
content,
types
and
they're
certain,
let's
say
scenarios
where
we
deleted
some
configurations,
but
we
never
actually
deleted
content,
because
deleting
a
content
is
actually
well
a
horrible
thing,
because
then
you
can.
B
A
right
because
the
content
is
not
the
thing
you
own,
so
even
though
you
have
built
the
web
part
and
you've
built
the
SS
to
support
it.
The
content
is
it's
created
by
by
users,
and
they
all
own
that,
and
even
though
they
remove
the
web
part
I
should
still
be
able
to
access
the
content
right.
Absolutely.
A
B
So,
as
you
said,
you
install
the
web
parts
on
the
scope
of
a
site,
so
that
means
that
features
you
create
are
also
sculpted
a
site
right,
correct.
Yes,
so
with
that,
actually
what
we're
doing
is
and
I've
heard
you
say
that
you
can
create
fields,
content,
types
and
lists,
so
all
of
that
would
be
created
on
the
level
of
a
site
right,
correct.
B
Absolutely
so
so,
if
I
understand
that
correctly
across
different
site
in
the
same
site,
collection
you'll
have
the
same
content
types,
but
in
different
instances
of
them
deployed
across
the
different
sites
within
without
a
central
location
to
manage
them.
So
you
could
end
up
in
scenario
where
site
a
has.
The
web
part
version,
1.0
and
site
B
version
2.0
and
the
common
types
that
they
use
are
not
compatible.
So
you
couldn't
exchange
the
info
across
to
web
parts.
That.
A
Is
absolutely
true
so
so
it
is
a
classic
recommendation
within
the
SharePoint
that
please
do
not
actually
provision
web
scoped,
content,
herbs
and
fields
in
the
case
of
client
side
where
client-side
web
parts.
That
would
be
actually
what's
happening
if
you
take
advantage
of
the
of
this
option.
So
what
representing
actually
in
here
and
let
me
come
back
on
the
on
the
more
let's
say-
Enterprise
write
a
scenario
in
a
second
as
well,
but
what?
But
that
would
definitely
mean.
Is
that
universe
case
scenario.
A
So,
therefore,
in
that
kind
of
a
scenario
when
we
talk
about
enterprise
deployment
development,
you
do
not
necessarily
need
to
deploy
the
content
types
as
part
of
your
web
part,
because
you
can
assume
that
they
already
exist
as
long
as
you
have
that
centralized
site
collection,
provisioning
engine
again,
not
a
black
and
white
discussion
and
really
comes
down
on
thinking
through
the
different
options.
Complexity
levels,
the
costs
related
on
the
on
the
individual
approaches.
A
B
And
then
so
imagine
that
whenever
we
write
code
to
create
stuff,
we
can
deal
with
errors
that
we
can
check
if
things
are
there,
how
do
we
deal
with
that
in
XML?
So
imagine
that
provisioning
fails
at
some
point.
How
can
we
see
what's
been
done?
What's
not
and
and
in
case
of
a
failure?
Does
it
go
all
the
way
back
or
are
we
start
with
some
things,
provision
and
the
others
not,
and
we
have
to
deal
with
that
in
one
way
or
another,
so.
A
In
the
case
of
using
the
future
framework
with
SPF
X
solution
packages,
you,
if
the
solution,
packets,
installation
to
the
site
fails,
it
is
essentially
the
same
UI
as
for
the
for
the
add-ins,
because
the
solution
packages
are
actually
deployed
using
during
catalog
as
well.
You
will
see
an
exception
you
will
see.
Essentially,
this
package
did
not
install
properly.
You
are
able
to
go
to
the
details
and
you're
able
to
see
Microsoft
in
general,
SharePoint
Online,
in
general
exception
around.
What
was
the
reason
for
failure
of
the
installation
now.
A
Will
that
explicitly
tell
you
what
was
the
path
which
was
wrong
or
something
else?
What
was
wrong?
It
depends
quite
often
those
people
who've
been
working
in
on-premises
and
found
solutions.
Did
they
actually
know
that
sharepoint
isn't
necessarily
always
giving
us
super
informative
exceptions,
so
it
might
be
that
isn't
that
it's
really
difficult
to
figure
out
what
actually
goes
wrong
within
your
department.
B
A
So
we
do
have
a
slide
actually
coming
up
after
the
demo
on
that
one
as
well.
But
that's
that's
a
fair
question,
so
we
do
support
future
favor
of
corporate
actions,
declarative,
upgrade
actions
which
were
introduced
back
in
SharePoint
2010
timeframe.
So
it's
exactly
the
same
story
as
switch
sharepoint
add-ins.
So
if
you've
done
the
upgrades
with
add-ins,
these
are.
A
This
is
exactly
what
happens
with
SharePoint
framework
solution
packages
as
well,
except
that
we
do
not
support
any
code
based
upgrade
operations
for
the
time
being,
so
you
can
actually
do
apply,
element
manifest,
and
then
you
are
able
to
do
at
field
two
content
type
as
a
custom
action.
Now
those
are
the
decorative
custom
actions
which
are
available
when
you
are
upgrading,
for
example,
from
your
package
version
1.0
2.0
now
in
the
future,
we're
looking
into
absolutely.
A
We
are
aware
of
this
challenge
as
well,
so
we're
looking
into
having
more,
let's
say,
code
based
ways
of
doing
your
upgrades
as
well,
most
likely
using
web
hooks
as
an
example
one
of
the
scenarios,
what
we're
looking
into,
but
we
don't
have
time
lines
for
those
at
this
point,
but
absolutely
in
the
in
engineering.
Looking
into
improving
this
model
for
the
for
the
solution
back,
it's
a
land
processing
as
well.
B
A
Sort
of
right
now
it
slightly
depends
on
a
tooling
what
using
so
when
you're,
creating
to
XML
itself.
Technically,
you
could
use
a
visual
studio
and
hook
in
that
XML
to
an
exercise
SD,
typically
able
to
using
visual
studio
code.
Research
to
do
code
actually
doesn't
have
any
schema,
validation
or
a
looking
schema,
adaption
or
schema
linking
for
XML
files,
which
would
mean
that
you
wouldn't
have
intelligence
whenever
actually
creating
the
element,
XML
files
and
but
it
does
slightly
depend
on
the
tooling.
What
you're
using
to
create
this
element.
A
Correct
so
whenever
you
are
then
packaging,
the
solution
whenever
will
run
the
package
solution
for
for
SPF
X
package.
We
do
not
do
validation
at
that
point.
When
you're
installing
the
SPB
Keiichi
file
that
catalog,
we
actually
do
a
validation.
So
at
that
point
we
run
through
the
basic
validation
of
the
ALM
into
xml
files.
We
do
not
check
the
logic
of
those
files,
but
with,
for
example,
check
that
the
paths
within
the
files
are
correct
and
and
you're
pointing
to
the
right
files
and
all
of
them
within
the
within
the
manifest
file.
A
But
that's
that's
pretty
much
the
level
of
their
validation,
which
we
have
right
now
and
that's
one
of
the
things
which
were
looking
into
getting
feedback
from
the
community
right
now
is,
is
the
the
improvements
of
the
tooling.
So
what
kind
of
additional
tooling
support
would
be
needed?
What
can
we
do?
What
can
a
visitors
to
their
code
guys
do
and
what
about
other
options
as
well.
A
Good
good
questions,
good
questions
and,
let's
quickly
have
a
look
on
this
before
we
go
to
the
demo
itself
just
to
quickly
pointing
out,
on
the
feature
framework
element,
support
for
SharePoint
framework
solution.
So
we
do
support
fields,
content
types
list,
instances
and
list
instances
with
custom
schema
and
I
want
to
explicitly
call
that
one
out.
That
does
not
mean
list
templates.
It
means
that
as
one
of
the
list
instance,
we
are
creating
a
list
and
provisioning
time
using
an
alternative
schema.
A
It
does
not
mean
a
custom
list,
template
which
could
be
a
template
available
within
a
site,
because
that
has
ten
additional
implications.
So
the
the
supported
set
of
capabilities
are
relatively
small,
but
they
are
addressing
that
simplistic
scenario
that
a
as
part
of
this
client
web
part
I'm,
going
to
create
a
list
which
has
the
basic
content
type
or
these
fields
inside
of
it
and
I
want
to
make
sure
that
that
exists
in
Iguala.
That's
the
scenario
what
this
one
is
addressing
right
now,
so.
B
The
only
thing
I
want
to
ask
about
that
about
the
one
that
you
wanted
to
point
out,
so
imagine
that
I
will
build
a
web
part
that
ships
with
a
list
a
custom
list
right
and
I
remove
the
web
part
I,
remove
the
package
the
list
stays
behind,
but
not
the
package
can
I
open,
open
the
list
and
access
it
or
not,
because
the
package
is
not
there
anymore.
So.
A
Whenever
you,
whenever
you
use
the
list
instance
with
the
custom
scheme,
option
which
we're
going
to
do
in
the
demo
as
well,
now
you
can
actually
retract
or
delete
the
solution.
Instance
from
a
site,
and
the
list
will
still
work
without
an
issue.
So
this
is
not
a
list
template
the
list.
Template
would
actually
mean
that
you're
creating
a
list
instance
is
based
on
schema
XML.
Whenever
retract
this
game
XML
is
no
longer
available.
Therefore,
the
list
instance
would
have
options.
A
A
Let's
see
that
code
and
what
I'm
gonna
do
is
that
I'm
gonna,
actually
I'm
gonna,
be
fully
open
and
honest
I
have
a
ready-made
solution
on
my
left
screen
and
what
I'm
gonna
do.
Is
that
I'm
going
to
build
this
solution
on
the
on
the
screen,
whatever?
What's
just
being
shared
with
you?
So
you
can
actually
see
how
we
built
the
solution
step
by
step.
B
A
Good,
so
what
I've
done
here
is
that
I've
simply
created
a
empty
solution,
and
this
is
a
empty
solution
using
the
the
basic
JavaScript
framework,
we're
not
actually
going
to
implement
anything
in
a
webpart
level.
So
it
doesn't
really
matter
what
we
what
template
we
are
using,
because
we
actually
play
with
the
solution
package,
which
is
now
our
objective
for
this
particular
demo.
A
So
when
I'm
going
to
first,
do
well
in
my
case,
I'm
going
to
actually
create
first,
a
SharePoint
folder
and
underneath
the
SharePoint
folder
I'm
gonna
create
an
assets
folder,
and
this
is
the
folder,
where
I'm
going
to
actually
do
all
of
my
element:
XML
files
and
schema
files,
and
so
on.
So
our
build.
Truly.
Whenever
we're
running
the
back
wheel
to
package,
it
will
automatically
look
for
element
external
files
and
upgrade
definitions
from
this
particular
folder.
A
Good
so
good,
we
have
a
location
for
our
assets,
so
let's
actually
create
a
few
assets,
and,
and
what
I'm
gonna
do
here
is
that
I'm
gonna,
like
mentioned
I'm
gonna,
be
super
well
fast
and
lazy.
But
what
I'm
gonna
do
is
that
I'm
gonna
use
the
exact
same
assets.
What
we
have
within
our
reference
sample,
which
I
think
I
published
a
few
days
ago
before
the
video
was
recording
so
I
know
that
it's
actually
live,
and
we
kind
of
link
that
sample
in
in
our
video
notes
as
well.
A
So
you
will
find
out
easily
so,
but
let's
quickly
come
on
this
trip,
because
not
that
maybe
there's
people
who
are
not
familiar,
what
we're
doing
for
my
future
framework
perspective,
so
element
XML
file,
is
something
which
is
defining
essentially
for
SharePoint
at
a
ship.
I
have
this
custom
solution
or
custom
definitions.
Whenever
you
activate
me,
I
want
to
have
certain
custom
things,
and
the
element
XML
file
then
actually
defines
what
are
those
things
or
elements
which
we
need
to
have
by
using
the
SharePoint
framework
classic
schema
the
feature.
A
What
we
call
this
camel
schema
feature
framework
schema,
and
in
this
case
we
are
creating
a
one
field
called
amount.
It
is
internal
using
SPF
X
amount
as
the
field
name,
it's
going
to
be
crude
in
the
SPF
X
columns
and
it's
going
to
be
a
currency
typed
with
the
two
decimals,
the
second
field.
It's
going
to
be
a
cost
Center
I'm
gonna
buy
the
for
well,
it's
good
practice
to
use
a
prefixing.
A
B
A
Can
have
multiple
and
you
can
still
define
the
order
of
those
files
within
a
feature,
so
that
does
work
as
well.
So
it's
just
in
this
particular
case.
I
only
have
few
items,
so
it's
a
one
file
from
a
simplicity
perspective,
but
you
can
have
more
goals
and
then
in
here
we
have
a
list
instance
list
instance,
which
is
based
on
a
template
type.
100,
that's
a
custom
list.
The
basic
list,
without
anything
else,
but
what's
actually
interesting
here,
is
that
I'm
using
a
custom
schema
attribute.
A
So
essentially,
what
I'm
saying
is
that
hey
create
me
a
custom
list,
but
in
a
provisioning
time
use
this
alternative
scheme
XML
so
do
not
use
the
native
schema
XML
off
the
template
list.
Template
100
use
this
alternative
scheme
XML,
which
I'm
gonna
actually
give
you
and,
as
you
can
see,
we
do
not
have
a
schema
XML
yet
so
let's
actually
create
a
schema
XML
to
this
folder
as
well.
So
let
me
actually
create
here
and
create
a
schema.
Xml
schema
examples
are
super
complex
and
super.
A
A
Studio
again
depends
on
your
tooling
what
you're,
using
for
schema
XML
that
schema
file
does
not
actually
natively
exist
because
well
the
reasons
are
in
others
for
years
and
years
of
evolution
in
SharePoint
we're
in
this
situation,
which
is
not
optimal,
but
you
can
pretty
much
see
what's
happening
here,
as
well
as
from
a
simplicity
perspective,
so
we're
defining
a
list.
Oop
I
said
that,
should
we
do
that?
It's
basic
list
that
title
is
not
relevant
in
this
case,
because
we're
overriding
that
in
the
list
instance
element
in
the
elements
XML
file.
A
But
what
I'm
doing
is
that
I'm
referencing
that
content
type,
which
I'm
actually
creating
in
the
elements
XML
file
as
well.
So
what
I
want
to
do
is
that
I
have
this
list
created
which
actually
has
by
default
these
fields,
SPF
X
amount,
an
SPF,
X
cost
Center
in
the
fifth
in
the
list
and
also
in
the
default
view,
and
then
some
basic
definitions
for
the
photo
view.
Part
which
is
needed.
Super
simplistic
schema,
XML
file.
These
files
can
be
super
complex.
A
This
file
can
be
painfully
complex
if
you're
familiar
with
SharePoint
internals
and
no
doubt
an
area
where
we
need
to
get
maybe
better
tooling,
maybe
better
explanation
there
is
good
stuff
include
documentation
out
there
in
the
internet
runs
game,
XML
file
as
well.
The
feature
XML
elements,
all
document
that
in
a
really
good
level,
so.
B
Don't
ask
about
and
I'm
worried
I
will
put
you
here,
a
butt
of
it
on
his
part.
It's
for
the
schema
XML
for
a
list
is
everything
that
we
could
have
done
in
a
pass
will
also
be
supported
in
the
the
modern
list
in
modern
sites,
or
are
there
pieces
that
we
should
not
use
because
it
might
work
in
classic
side,
but
not
in
modern
side,
more
or
less
so.
A
A
Now,
if
you
reduce
the
schema
XML
which
works
100%
in
classic
and
it
will
you
can
provision
lists
using
that
in
one
our
sites
as
well,
but
it
might
be
that
some
configurations
will
be
ignored
by
the
modern
list,
UI
some
of
the
the
known
capabilities.
Well,
some
of
the
there
has
been
some
gaps
in
the
modern
lists
and
libraries
and
those
are
being
at
rest
scratch
early
and
and
those
things
are
paying
light
up
here
and
there
as
we
move
along.
So
you
can
anyway,
provision
to
the
list.
A
A
Correct
correct
so
anything
in
a
classic
schema
and
you
can
still
use
that
in
creation
time
what
will
be
then
visible
in
the
modern
versus
classic?
That's
a
different
discussion
good.
So
we
want
to
have
a
list
with
those
three
fields
and
by
default
in
the
default
view
in
here
we
created
the
two
fields.
There
was
two
title
field:
that's
the
third
field
and
we
have
a
content
type.
We
are
creating
a
list
instance
and
saying
hey:
that's
the
scheme
XML,
which
one
actually
used
for
creating
this
instance
to
the
side.
A
Good
now,
I
need
to
actually
make
sure
that
this
stuff
is
getting
packaged
as
part
of
my
packets
and
so
and
it
actually
modify
my
package
solution,
JSON
files
in
the
config
folder.
So
let's
actually
come
in
here.
This
is
defining.
Essentially,
what
is
the
name
of
my
solution
so,
for
example,
feature
solution,
SPP
mad
ji
and
what
is
the
version
of
my
solution
file
essentially
same
as
let's
say,
adding
version
back
in
the
adding
time
frame
or
farm
solution
version
when
we
were
back
in
the
on-premises
timeframe.
A
So
in
the
package
solution,
I
need
to
extend
slightly
and
I'm
going
to
copy
this
directly
again
from
the
sample
which
we
are
having
so
I'm
gonna
actually
create
the
absolutely
right
because
well,
you
can
easily
do
typos
with
this
one
and
I'm
being
lazy,
not
that
one.
Once
again
that
looks
scary
here
and
put
that
money.
So
inside
of
the
feature
element,
I'm
introducing
features
collection,
which
actually
implies
like
adults,
that
you
can
actually
have
technically
multiple
features
and
there
as
well,
and
then
we
have
a
title
of
the
feature.
A
B
So,
if
I
understand
correctly
what
you
said,
this
feature
will
be
available
in
Oroville
will
be
you
be
actually
shown
in
the
UI.
But
if
I
recall
correctly
the
feature
that
that
actually
or
was
it
in
a
past-
that
in
the
past
that
was
a
feature
that
deployed
the
dot
web
part
file
filed
to
gallery.
And
that
is
not
visible
anymore,
because
that
one
was
was.
A
As
born
of
the
packaging
of
the
solution,
we
actually
did
package
a
dot
whip
art
file
as
part
of
the
web
part
client-side
web
port,
for
we
no
longer
do
des
so
we're
not
actually
deploying
a
dot
web
port
file
as
part
of
the
feature,
the
web
part
gets
visible
in
the
site
level
using
different
mechanism,
so
we
don't
actually
need
to
have
to
go
to
a
port
foil
anymore.
This
feature
will
be
visible
in
the
site
features
list.
B
There
may
be
a
valid
option
to
check
whether
everything
has
been
installed
correctly.
Right
course
to
see
that
thing
is,
is
enabled
right,
because
you
might
have
backup
and
restore
automation
process,
and
there
are
many
things
that
could
have
affected
so
being
a
able
to
actually
see
whether
it's
enabled
or
not
might
be
like
the
first
step
that
you
would
take
in
order
to
see
if
everything
were
like
I
expect.
I
said.
A
Correct
correct
and
we
could
actually
call
this
something
like
SPF
X
feature
solution,
so
you
can
always
easily
find
that
from
the
feature
list
as
well.
Every
feature
has
to
have
a
unique
ID.
I'm
gonna
use
the
same
unique
ID
as
I
used
for
the
other
one
in
drug
doesn't
really
matter
in
this
case
and
then
I'm
referring
the
element,
XML
file
and
sky
maximum
file.
So
you
notice
that
I'm
not
actually
pinpoint
that
they
are
in
SharePoint
assets,
folder
I'm.
A
Essentially,
the
tooling
is
assuming
that
they
are
in
the
assets
folder
on
inside
of
the
or
a
subfolder
in
the
fear,
ship
and
folder,
and
then,
if
needed,
I
would
be
able
to
actually
extend
this
with
upgrade
actions.
But
in
this
case
we're
not
gonna
actually
do
this
upgrade
action
fields
if
I
remember
correctly.
What's
the
right
definition,
I'm
gonna
reference,
the
the
current
documentation
in
the
video
webcast,
a
video
notes
as
well,
so
that
would
be
then
related
on
the
upgrade
actions
when
you're
upgrading
across
two
versions.
So.
A
So
I
would
be
able
to
actually
have
here
multiple
elements
file.
So
here
that
would
be
the
nelem
ins
tree
and
that
with
the
elements
too,
and
they
would
be
actually
queued
up
in
the
right
order
in
the
tool,
so
we
would
produce
stuff
in
a
one
two
three
way,
not
based
on
a
number
based
on
the
existence
and
orders.
Yes,
exactly
yeah
good,
it's
actually
up
and
let's
get
rid
of
those
and
there
we
go
I
think
we
should
be
fine
with
this
one.
There's
nothing
more
than
this
to
be
done.
A
We
have
the
element
XML
files.
We
have
the
definition
for
the
underlying
situation.
I
think
we're
good
to
go,
wait
so
ship
it.
So
let
me
do
this
time.
I
can
do
call
package
solution
and
this
will
essentially
ten
read
the
package
solution,
JSON
file
and
it
will
create
the
internals
of
the
feature
internals
of
the
file.
It
gets
me
the
sbpp
KJ
file,
as
we
can
see
in
here,
which
will
then
contain
all
of
the
needed
assets
and
everything
else.
A
If
you're
super
interested
on
what's
happening
inside
of
the
engine,
you
can
actually
see
those
fast.
So
you
don't
have
to
extract
that
SP
B
KJ
file.
You
can
go
underneath
the
solution
folder,
but
you
can
find
the
file
you
can
go
to
the
D
debug
folder.
You
can
actually
find
the
XML
files
which
were
being
packaged
in
here.
We
can
say
that
we
have
the
schema
XML
file
correctly
here,
so
the
tooling
is
able
to
recognize
that
we
have
a
feature
definition
here.
We
have
a
fit
another
feature
definition
here.
A
There's
our
SP
FX
feature
solution.
There's
our
description.
Looking
all
good
scoping
whip,
like
we
mentioned
in
advanced
and
then
you're
able
to
see
the
individual
element
XML
file,
for
example
in
here.
The
other
element
XML
file,
is
the
definition
of
the
hello
world
web
board.
So
this
is
essentially
the
client
side
component,
which
is
a
type
of
hello
world
web
part.
Sorry
type
of
a
web
part
right
now,
as
we
can
see
in
here,
because
in
future
there
will
be
alternative
or
other
types.
Well,
not
just
web
part.
So.
B
B
A
And
that's
a
really
really
good
question
to
actually
cover
in
this
video
as
well,
because
we
don't
probably
then
cover
that
too
much
detailed
in
the
in
the
documentation.
What
actually
happens
is
that
we
are
taking
advantage
so
for
else
and
relationship
files.
So
in
the
in
the
classic
development
you
were
actually
defining
the
element
XML
files
in
here,
so
you
were
using
element
file,
element
file
and
then
you
reference
that
file
somewhere
and
all
of
that
and
upgrade
definition
here
as
in
art.
This
chilling.
A
All
of
that
is
taken
care
of,
so
you
don't
actually
need
to
do
that.
You
don't
need
to
do
all
of
that
manually
associating
things
we
essentially
read.
What's
in
the
package
solution
changes
on
file
and
then
we
create
this
relationship
files,
and
these
are
the
relationship
files
relationships
is
a
really
classic
XML
definition
for
future
framework
as
well,
and
this
one
is
actually
defining,
for
example,
that
we
have
a
feature
element
manifest,
which
is
that
one,
which
is
for
Excel
for
the
web
part.
We
do
have
a
feature
element
manifest,
which
is
sorry.
A
Let's
see
this
one
in
practice
quickly,
so
I
think
we
went
through
how
we
can
do
that.
So
I'm
gonna
actually
reveal
this
folder
in
Explorer,
not
open,
reveal
and
then
I'm
gonna
deploy
this
to
the
SharePoint.
So
let
me
actually
start
back
on
my
ship
one
side.
This
is
one
of
the
one
clean
team
sites
at
native
artwork
SharePoint
team
site
in
SharePoint
Online.
So
let's
actually,
let's
actually
get
that
solution
installed.
Here
we
go.
There's
our
solution
and
let
me
actually
do
that.
A
There
we
go
and
I
can
track
and
drop
the
solution
file
in
and
here
we
go.
The
solution
file
is
getting
installed,
I'm,
getting
that
right
dialogue.
If
this
doesn't
actually
happen.
You
know
that
there's
something
wrong
within
your
feature
within
your
solution
file,
either
in
a
feature
framework
or
in
some
other
sections
of
your
solution
file.
The
fact
that
you're
getting
this
dialog
means
that
hey
it
is
recognizing
that
properly
as
a
client
satisfaction.
A
It
actually
says
in
here
as
well
that
this
one
is
a
valid
package,
and
that
means
that
it
has
been
validated
to
package
that
is
defiled
references
and
everything
is
working
problem,
good
solution
back,
it's
deployed.
So
let's
get
this
one
then
activated
within
our
clean
site,
clean
SharePoint
site,
let's
go
to
the
site
contents
and
in
here
as
an
end
user,
I
don't
need
to
have
the
sufficient
permissions
to
create
lists
because
we
are
elevating
when
we
are
running
this
code
in
the
future
framework.
A
So
I'm
gonna
choose
feature
salvation
client-side
solution,
which
is
the
one
which
we
just
created
and
uploaded.
Let's
install
this
one
to
the
site
and
that's
getting
installed
using
the
the
classic,
let's
say
adding
model
process,
except
that
we're
not
creating
an
adding
web
or
app
web
and
we're
not
applying
those
feature
framework
elements
to
the
adding
web
or
app
whip
whatever.
We
want
to
call
that
what
happens
here.
A
If
I
refresh
the
UI,
we
are
actually
applying
these
modifications
directly
on
this
particular
site,
so
to
say
host
web,
but
in
the
SPF
X
world
we
don't
have
a
term
called
host
web,
that's
more
for
the
adding
model.
The
activation
of
the
of
the
solution
can
take
a
while.
Now
it
didn't
take
too
long.
I
was
just
about
to
talk
about
to
have
a
pause
on
the
video,
and
now
it's
activated.
If
I
refresh,
we
can
see
that
we
have
an
SPF
X
list,
which
was
list
instance
which
exists
now
on
the
site.
A
If
we
go
to
this
list
itself,
we
can
actually
say
that
we
have
a
three
items
in
the
in
the
list.
I
can
create
a
new
item
and
I
can
say
that
I
have
an
amount
field.
I
have
a
cost
center
field
with
the
right
values.
Let's
call
this
and
that
will
say
currency,
so
it's
not
gonna
actually
accept
even
others.
I
can
do
numbers
and
just
save,
and
we
can
say
that
we
know
we
did
not
list
you.
A
I
want
to
have
a
really
simplistic
list
with
the
specific
fields
created
whenever
the
client-side
web
bar
is
getting
installed
on
the
site
and
now,
when
the
client-side
web
part
is
being
used
on
the
UI
add
this
list
exists
and
nobody
has
to
manually
create
that
or
we
don't
have
to
run
JavaScript
to
actually
get
it
created.
So
all
good
from
that
perspective,
and
obviously
if
we
want
to
just
double
check
final
things,
if
you
go
to
the
site
settings
side
columns,
we
can
go
to
the
list
of
SPF
x
columns.
B
A
Well,
that's
that's
always
true.
Within
the
SharePoint,
and
that's
always
personal
I
said
that
I,
don't
believe
anybody
who
is
presenting
best
practices
sessions
in
conferences,
because
you
can't
it's
impossible
to
define
best
practices
for
almost
any
technology,
because
best
practices
depends.
Is
this
the
best
practice
to
deploy
a
list
or
is
the
the
remote
provisioning
model
best
practice
to
deploy
a
list?
Well,
it
depends.
Are
you
writing
a
most
simplistic,
a
web
part?
Or
are
you
writing
a
hardcore
enterprise
solution
for
a
large
customer?
A
Cool,
so
let's
actually
move
on
and
just
the
final
thing
we
kind
of
a
mentioned
this
one
already
well
dick
asked
a
question
around
this
one.
So
around
update
and
upgrade
story,
the
moral
does
support,
also
usage
of
the
feature,
upgrade
actions
so
to
apply
element
manifest
and
the
add
content.
I
failed.
It
is
isn't
the
massive
amount
of
elements
which
are
being
supported,
but
those
are
the
classic
declarative
options
which
we've
been
having
for
shipment
add-ins
as
well.
A
These
upgrade
actions
are
being
processed
to
win.
The
instance
of
the
site
is
being
operated,
so
it
doesn't
mean
that
when
you're
in
the
same
way
as
with
add-ins,
whenever
you
were
installing
a
new
version
that
catalog
that's
not
when
we
actually
apply
and
this
these
modifications,
you
need
to
actually
go
to
the
site
level
and
do
an
explicit
upgrade,
and
that
then
raises
the
follow
up
question
here,
but
wouldn't
that
require
that
I
need
to
go
to
all
of
the
sites
and
do
the
upgrade
manually
one
by
one.
A
B
A
So
that
that
is
an
answer,
some
questions
listings
answer
is
no
and
that
that
option
does
not,
unfortunately,
Burak
which
SharePoint
framework
solutions.
The
reason
why
it
worked
well,
the
difference
is
actually
the
way
how
to
adding
model
works
with
an
add-in
whip
and
add
web
whatever
app
web,
whatever
it's
called
app
web,
the
the
motor.
What
waldek
is
referring
is
that
the
centrally
deployed
or
tenant
level
deployed
add-ins,
where
you
actually
create
an
instance
of
the
add-in
to
the
catalog
site,
and
then
you
push
that
instance
to
be
visible
across
the
sides.
A
But
what
happens
with
that
scenario?
Is
that
you're
essentially
adding
a
link
to
that
app
web
across
all
of
the
sites
within
your
tenon
and
in
the
case
of
SharePoint
framework
solutions?
You
actually
need
to
get
the
stuff
provision
to
the
individual
sites,
and
so
we
will
get
the
instances
everything
else
deployed
to
that
particular
sites,
and
so
that
model
does
not,
unfortunately,
work.
But
whenever
we
get
the
ALM
api's
available,
then
you
can
actually
start
automating
deployments
cross
the
tenant
across
all
of
the
sites,
if
needed,
or
are
crates
and
more
control
in
general.
A
For
SharePoint
framework
solutions,
good
quite
a
lot
of
talking
quite
a
large
demos,
but
I
think
one
of
the
key
objective
of
this
webcast
Rose
would
really
walk
through
the
whole
process
carefully
one
by
one.
The
only
aspect
which
we
did
in
deep
time
was
the
upgrade
or
create
upgrade
action
or
operate
process,
and
we
will
absolutely
document
that
as
well.
So
that
will
be.
You
know
in
a
lab
unless
the
lab
is
already
available
when
you're
watching
the
video
in
the
left
of
that
home,
slash
SharePoint,
so
you
can
actually
understand
also.
A
How
would
I
then
update
this
kind
of
an
ad
adding
or
sorry
not
an
adding
share
pod
framework
solution
which
had
a
future
framework
and
elements
inside
of
it?
We
would
we
wanted
to
skip
that
one
in
this
call
webcast,
because
again,
we've
been
talking
way
too
much
already,
but
it's
better
the
reference
that
one
essay
written
lab
in
the
in
the
documentation
anything.what
anything
else
what
we
want
to
cover
Waldeck
any
questions
any
you
didn't
actually
ask
any
hard
questions.
I'm
not
going
to
tell
you
what
are
the
hard
questions?
No
just
kidding.
B
Also,
to
close
it
off
I'd
like
to
reiterate
that
declarative
provisioning
is
yet
another
tool
available
to
you,
but
it's
not
recommended
there
are
best
approach
or
just
it
just
an
approach
that
you
should
think
about,
and
you
should
decide
whether
to
use
it
or
not
whether
it
applies
to
you
or
not.
So
it's
not.
You
should
never
bloom,
kindly
stare
at
it
and
say
I'm
going
to
do
it
or
I
am
NOT
going
to
do
it
B,
because
X,
but
just
think
about
it.