// AllowNFSNormalPlanSizes 指定可能なNFSサイズ(標準プラン)
977162
func AllowNFSNormalPlanSizes() []int {
	return []int{
		int(NFSSize100G),
		int(NFSSize500G),
		int(NFSSize1T),
		int(NFSSize2T),
		int(NFSSize4T),
		int(NFSSize8T),
		int(NFSSize12T),
	}
}
920769
func (s *IndicesGetService) AllowNoIndices(allowNoIndices bool) *IndicesGetService {
	s.allowNoIndices = &allowNoIndices
	return s
}
984449
func (s *IndicesUnfreezeService) AllowNoIndices(allowNoIndices bool) *IndicesUnfreezeService {
	s.allowNoIndices = &allowNoIndices
	return s
}
309422
func (f *File) CalcNormSignalMax() (ret float64, err error) {
	e := C.sf_command(f.s, C.SFC_CALC_NORM_SIGNAL_MAX, unsafe.Pointer(&ret), 8)
	if e != 0 {
		err = sErrorType(e)
	}
	return
}
869939
func (s *IndicesGetSettingsService) AllowNoIndices(allowNoIndices bool) *IndicesGetSettingsService {
	s.allowNoIndices = &allowNoIndices
	return s
}
849740
func (p NFSPlans) FindPlanID(plan NFSPlan, size NFSSize) int64 {
	var plans []NFSPlanValue
	switch plan {
	case NFSPlanHDD:
		plans = p.HDD
	case NFSPlanSSD:
		plans = p.SSD
	default:
		return -1
	}

	for _, plan := range plans {
		if plan.Availability == "available" && plan.Size == int(size) {
			res, err := plan.PlanID.Int64()
			if err != nil {
				return -1
			}
			return res
		}
	}

	return -1
}
116039
func (s *CloseIndexService) AllowNoIndices(allowNoIndices bool) *CloseIndexService {
	s.allowNoIndices = &allowNoIndices
	return s
}
874899
func (s *SearchRequest) AllowNoIndices(allowNoIndices bool) *SearchRequest {
	s.allowNoIndices = &allowNoIndices
	return s
}
134166
func (s *SearchService) AllowNoIndices(allowNoIndices bool) *SearchService {
	s.allowNoIndices = &allowNoIndices
	return s
}
1132838
func (s *IndicesPutSettingsService) AllowNoIndices(allowNoIndices bool) *IndicesPutSettingsService {
	s.allowNoIndices = &allowNoIndices
	return s
}
1185209
func (s *StanServer) configureClusterOpts() error {
	opts := s.natsOpts
	// If we don't have cluster defined in the configuration
	// file and no cluster listen string override, but we do
	// have a routes override, we need to report misconfiguration.
	if opts.Cluster.ListenStr == "" && opts.Cluster.Host == "" &&
		opts.Cluster.Port == 0 {
		if opts.RoutesStr != "" {
			err := fmt.Errorf("solicited routes require cluster capabilities, e.g. --cluster")
			s.log.Fatalf(err.Error())
			// Also return error in case server is started from application
			// and no logger has been set.
			return err
		}
		return nil
	}

	// If cluster flag override, process it
	if opts.Cluster.ListenStr != "" {
		clusterURL, err := url.Parse(opts.Cluster.ListenStr)
		if err != nil {
			return err
		}
		h, p, err := net.SplitHostPort(clusterURL.Host)
		if err != nil {
			return err
		}
		opts.Cluster.Host = h
		_, err = fmt.Sscan(p, &opts.Cluster.Port)
		if err != nil {
			return err
		}

		if clusterURL.User != nil {
			pass, hasPassword := clusterURL.User.Password()
			if !hasPassword {
				return fmt.Errorf("expected cluster password to be set")
			}
			opts.Cluster.Password = pass

			user := clusterURL.User.Username()
			opts.Cluster.Username = user
		} else {
			// Since we override from flag and there is no user/pwd, make
			// sure we clear what we may have gotten from config file.
			opts.Cluster.Username = ""
			opts.Cluster.Password = ""
		}
	}

	// If we have routes but no config file, fill in here.
	if opts.RoutesStr != "" && opts.Routes == nil {
		opts.Routes = server.RoutesFromStr(opts.RoutesStr)
	}

	return nil
}
630742
func (s *PutMappingService) AllowNoIndices(allowNoIndices bool) *PutMappingService {
	s.allowNoIndices = &allowNoIndices
	return s
}
1146247
func ErrNumConfsTooLarge(numConfs, maxNumConfs uint32) error {
	return ReservationError{
		fmt.Errorf("minimum depth of %d is too large, max is %d",
			numConfs, maxNumConfs),
	}
}
844269
func (s *AwsSecurityFindingFilters) SetSeverityNormalized(v []*NumberFilter) *AwsSecurityFindingFilters {
	s.SeverityNormalized = v
	return s
}
303307
func (s *PercolateService) AllowNoIndices(allowNoIndices bool) *PercolateService {
	s.allowNoIndices = &allowNoIndices
	return s
}
305502
func (a *ACL) AllowNamespaceOperation(ns string, op string) bool {
	// Hot path management tokens
	if a.management {
		return true
	}

	// Check for a matching capability set
	capabilities, ok := a.matchingCapabilitySet(ns)
	if !ok {
		return false
	}

	// Check if the capability has been granted
	return capabilities.Check(op)
}
400973
func WithMinSplitSize(n int) Option {
	return func(o *options) {
		if n > 0 {
			o.minSplitSize = n
		}
	}
}