this.dialect = dialectId;
    }


    /**
     * @return the smb2
     */
    public final boolean isSMB2 () {
        return this.smb2;
    }


    /**
     * @return the dialect
     */
    public final int getDialect () {
        if ( !this.smb2 ) {
            throw new UnsupportedOperationException();
        }
        return this.dialect;
    }


    /**
     * 

        return queryBuilder.isFragment();
    }

    @Override
    public QueryBuilder queryName(final String queryName) {
        return queryBuilder.queryName(queryName);
    }

    @Override
    public String queryName() {
        return queryBuilder.queryName();
    }

    @Override
    public float boost() {
        return queryBuilder.boost();
    }

    @Override

            }
            return entity;
        }).orElseGet(() -> {
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL));
            return null;
        });

        return asJson(new ApiUpdateResponse().id(relatedContent.getId()).created(true).status(Status.OK).result());
    }

	if ipToInsert.Is6() {
		return m.Deps.addIP(m.V6Name, ipToInsert, ipProto, comment, replace)
	}
	return m.Deps.addIP(m.V4Name, ipToInsert, ipProto, comment, replace)
}

func (m *IPSet) DeleteIP(ip netip.Addr, ipProto uint8) error {
	ipToDel := ip.Unmap()

	// We have already Unmap'd, so we can do a simple IsV6 y/n check now
	if ipToDel.Is6() {
		return m.Deps.deleteIP(m.V6Name, ipToDel, ipProto)
	}

type ErrUnknownRegion struct {
	Region string
}

func (err ErrUnknownRegion) Error() string {
	return fmt.Sprintf("unknown region '%v'", err.Region)
}

// ErrARNNotFound - ARN not found error.
type ErrARNNotFound struct {
	ARN ARN
}

func (err ErrARNNotFound) Error() string {
	return fmt.Sprintf("ARN '%v' not found", err.ARN)
}

// ErrInvalidARN - invalid ARN error.
type ErrInvalidARN struct {

	appendFile, err := lock.Open(dst, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0o666)
	if err != nil {
		return err
	}
	defer appendFile.Close()

	srcFile, err := lock.Open(src, os.O_RDONLY, 0o666)
	if err != nil {
		return err
	}
	defer srcFile.Close()
	_, err = io.Copy(appendFile, srcFile)
	return err

            if (!isIncubating((JApiHasAnnotations) member) && !isInject((JApiHasAnnotations) member)) {
                return violationError(member);
            }
        }
        return null;
    }

    private Violation violationError(JApiCompatibility member) {
        return acceptOrReject(member, Violation.error(member, "Is not annotated with @Incubating"));
    }

        if (sessionId == null) {
            return null;
        }
        return pathMappingMap.get(sessionId);
    }

    public String replaceUrl(final String sessionId, final String url) { // for crawling
        final List<PathMapping> pathMappingList = getPathMappingList(sessionId);
        if (pathMappingList == null) {
            return url;
        }
        return replaceUrl(pathMappingList, url);
    }

      if (from == Bound.NO_BOUND && to == Bound.INCLUSIVE) {
        return map.headMap(lastInclusive, true);
      } else if (from == Bound.EXCLUSIVE && to == Bound.NO_BOUND) {
        return map.tailMap(firstExclusive, false);
      } else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) {
        return map.subMap(firstExclusive, false, lastExclusive, false);

    @Override
    protected Set<T> delegate() {
      return backingSet;
    }

    @Override
    public boolean equals(@Nullable Object object) {
      return standardEquals(object);
    }

    @Override
    public int hashCode() {
      return standardHashCode();
    }

    @Override
    public boolean addAll(Collection<? extends T> collection) {
      return standardAddAll(collection);
    }

    @Override