// MValidationExternal ...
504202
func (cm AsStandard) MValidationExternal(resource string) *metadata.MValidationExternal {
	mve := metadata.MValidationExternal{}
	mi := metadata.MIValidationExternal
	for _, cd := range cm.Elements[mi.Name] {
		if cd.Attr["Resource"] != resource {
			continue
		}
		metadata.FieldTransfer(cd.Attr).To(&mve)
		for _, entry := range cd.Entries() {
			tmp := metadata.ValidationExternal{}
			entry.SetFields(&tmp)
			id := mi.ID(&tmp)
			tmp.MValidationExternalType = cm.MValidationExternalType(resource, id)
			mve.ValidationExternal = append(mve.ValidationExternal, tmp)
		}
	}
	return &mve
}
535779
func SetExternalKey(controllerID string, containerID string, key string) error {
	return types.NotImplementedErrorf("SetExternalKey isn't supported on non linux systems")
}
214349
func (s *IndexFacesInput) SetExternalImageId(v string) *IndexFacesInput {
	s.ExternalImageId = &v
	return s
}
16188
func (s *VirtualMachineService) NewExpungeVirtualMachineParams(id string) *ExpungeVirtualMachineParams {
	p := &ExpungeVirtualMachineParams{}
	p.p = make(map[string]interface{})
	p.p["id"] = id
	return p
}
866674
func (v *Volume) InspectExternal(ctx context.Context) (*client.Volume, error) {
	volumes, err := v.context.Client.Volume.List(&client.ListOpts{
		Filters: map[string]interface{}{
			"name": v.name,
		},
	})
	if err != nil {
		return nil, err
	}

	if len(volumes.Data) > 0 {
		return &volumes.Data[0], nil
	}

	return nil, nil
}
463294
func NewExternalCA(intermediates []byte, tlsConfig *tls.Config, urls ...string) *ExternalCA {
	return &ExternalCA{
		ExternalRequestTimeout: 5 * time.Second,
		intermediates:          intermediates,
		urls:                   urls,
		client: &http.Client{
			Transport: &http.Transport{
				TLSClientConfig: tlsConfig,
			},
		},
	}
}
425385
func (s *ModifyHsmInput) SetExternalId(v string) *ModifyHsmInput {
	s.ExternalId = &v
	return s
}
72337
func (s *AssumeRoleInput) SetExternalId(v string) *AssumeRoleInput {
	s.ExternalId = &v
	return s
}
786744
func (s *ActionExecution) SetExternalExecutionId(v string) *ActionExecution {
	s.ExternalExecutionId = &v
	return s
}
764954
func (m *Manager) ScopesForInternalAddrTypes(addrType AddressType) []KeyScope {
	m.mtx.RLock()
	defer m.mtx.RUnlock()

	scopes, _ := m.internalAddrSchemas[addrType]
	return scopes
}
1031438
func (s *Endpoint) SetExternalId(v string) *Endpoint {
	s.ExternalId = &v
	return s
}
2072
func (p *PUContext) RetrieveCachedExternalFlowPolicy(id string) (interface{}, error) {
	return p.externalIPCache.Get(id)
}
726527
func NewExternalFacade(context facade.Context) (*Facade, error) {
	st := context.State()
	auth := context.Auth()

	m, err := st.Model()
	if err != nil {
		return nil, err
	}

	claimer, err := context.SingularClaimer()
	if err != nil {
		return nil, errors.Trace(err)
	}

	backend := getBackend(st, m.ModelTag())
	return NewFacade(backend, claimer, auth)
}
1092593
func (s *HistoryEvent) SetExternalWorkflowExecutionSignaledEventAttributes(v *ExternalWorkflowExecutionSignaledEventAttributes) *HistoryEvent {
	s.ExternalWorkflowExecutionSignaledEventAttributes = v
	return s
}
45096
func (s *S3Settings) SetExternalTableDefinition(v string) *S3Settings {
	s.ExternalTableDefinition = &v
	return s
}
639419
func (s *Face) SetExternalImageId(v string) *Face {
	s.ExternalImageId = &v
	return s
}
249420
func (v *Volume) SetExternalVolume(name, provider string) *ExternalVolume {
	ev := &ExternalVolume{
		Name:     name,
		Provider: provider,
	}
	v.External = ev
	return ev
}